F1000Research, an open research publishing platform, is excited to announce that researchers can now publish interactive figures created with Plotly in the online version of their publications; a first for a scientific publisher. To encourage researchers to embrace interactivity, F1000 is reducing the open access publishing charges for all articles containing an interactive Plotly figure by 50% (authors need to submit by December 31st 2017 to be eligible for the reduction). The best will be featured on both F1000Research and Plotly throughout the year. A full overview of the initiative can be found here and details on how to submit Plotly figures to F1000Research can be found here at the F1000 blog.

So long, static charts! 👋

Why are we making a concerted effort to encourage researchers to publish interactive figures? Well, scientific publishing made the transition to the web almost two decades ago, and yet the research community still treats online articles as if they have the same physical limitations as their printed equivalents. We even still use terms such as ‘papers’ and ‘pre-prints’ to refer to works that only exist online.

The same is of course true for elements within articles, including figures. They may now be in digital formats rather than drawn freehand, but graphs still remain in the same static state since William Playfair created the first statistical charts in 1786.

F1000Research publishes articles in the life sciences and related disciplines. Since we launched in 2012, we have worked hard to crumple the idea that online publications have the same properties as paper. We were the first to implement a versioning system so authors can update their articles, and everything we publish is fully open, with all articles open access, and associated data, code and signed peer review reports made publically available for others to use. None of this is possible in the un-linkable paper pages of a space-constrained print journal.

We have also experimented with publishing interactive figures (as have a small number of other academic publishers), and we went as far as publishing the first ‘living’ figure in a research article. However, all efforts to date have been custom-built attempts that were either scalable but not flexible with regards to figure type, or flexible but not scalable. Plotly, which launched the same year as us, has built a platform that excels at both, with elegant aesthetics as an added bonus. So, we are leaving it to the data visualization experts and focusing our efforts on supporting their tech.

The founding Plotly team also has scientific publishing roots. Alex Johnson, Plotly’s CTO, won the Newcomb Cleveland Prize for his paper coauthored in Science during his PhD. Jack Parmer, CEO, published his first physics paper at age 21. The Plotly team is dedicated to helping bring scientific publishing into an era of rich, interactive figures that enhance reproducibility and insight.

Finding clarity in interactivity

The entire purpose of a scientific figure is to help readers understand; information visualized graphically is much easier to comprehend than a table densely packed with numbers or a long tract of text.

That said, biological and environmental systems are complex and so they can still be difficult to represent in a static 2D figure. This is especially true if the research involves lots of variables or large quantities of data. Many readers of scientific articles will have struggled to decipher over-plotted charts, or network graphs crowded with hundreds of nodes all labelled in an unreadable font size just so the figure fits with the paper’s margins. Being able to zoom, filter, and hover over individual data points to see their values, which all Plotly figures have by default, addresses these challenges and helps readers to properly explore data at a much finer scale.

Interactive and dynamic scientific figures have other advantages over their static counterparts. If there are several ways to visualize your data, you no longer have to choose just one; if you want to demonstrate how different input values affect a model’s outputs, you can achieve this graphically; and if you want to represent the interplay of many variables, you can make use of dynamic changes in the size, color, shape, and location of data points over time.

Perhaps the greatest benefit is that interactivity and dynamism help graphs grab your attention. Hans Rosling’s lectures on the Gapminder visualization would certainly not have racked up the 10s of millions of views had it been static (plus it would probably have to be split into several graphs to makes sense). The use of color, size changes and movement help us to emotionally engage with the data, which in turn helps us appreciate the real-world processes they represents. Scientific articles are becoming increasingly difficult to read; used appropriately, interactive figures have the potential to help counteract this trend. This is especially true when communicating findings to policy makers and the wider general public.

The tech has been developed and the benefits are clear, so why should we be content with static figures?

Today, Plotly is trusted by some of the largest enterprises in the world. This includes organizations like Google, NASA, Shell Oil, and many more. Our enterprise initiatives began three years ago after multiple requests for an enterprise, installable version of our product. At first, we tried to drive these customers to our cloud-hosted SaaS product. Companies like Salesforce and Box were pushing the conversation towards trusted and secure cloud SaaS applications, and we assumed we could chart a similar course.

While some customers could be convinced to adopt our cloud-based solution, other companies had deeper reservations or contractual/regulatory requirements that prevented them from using multi-tenant environments. It was clear that if we wanted enterprises to widely adopt Plotly we needed to solve on-prem and private instance deployments.

After making the decision to offer an installable version of Plotly we started exploring the developer community’s best practices for inspiration. Our friends at GitHub had generated a lot of customer value with their enterprise offering so we reached out with hopes of gaining some of their insights. Their main advice was that if they could start over they would use containers rather than shipping the entire application as a VM. They explained that this would allow their on-prem product to leverage the same cloud-native architecture as their SaaS product.

From that insight, we knew we needed a container based solution with a standard installation process that could cater to a variety of environments.

Building it ourselves

For our first enterprise offering we Dockerized our application, putting all of our services into one (BIG) Docker image, rather than splitting them up. This was an inconvenient way of structuring our application, but at the time there weren’t any mature Docker orchestration solutions available so we didn’t really have a choice. We lined up our first customer who was very technical and (luckily for us) knew Docker & Linux quite well. When it came time for them to install Plotly On-Premise we used `docker export` to produce tarballs which we delivered in an S3 bucket, they’d download the tarballs, unpack, manually edit a few config files and use Docker’s CLI to get everything up and running.

Things seemed to be working! We started to push this approach to more customers.

After 2 releases, 10 customer trials, and 5 actual buyers we quickly found out that not all of our customers would be like our first. It turned out they weren’t as comfortable with the Docker CLI or VIM. We also started running into a few quirky issues with Docker, specifically when it came to proxied servers and AUFS, all of which led to support issues and a few messy installs.

It was a functional process but each deployment felt like a one-off project. We needed to involve our developers in each installation rather than letting our sales and support teams manage the installation independently. On-prem deployments were taking up as much effort as some of our core features.

A new approach

We went back to the drawing board for a new approach and were quickly introduced to a company building a platform aimed at solving enterprise deployments, Replicated. At the time, they were mainly working with developer tools we trusted like Travis CI and npm. The Replicated platform was driven by Docker images as the unit of portability, so from the start we agreed on the fundamental approach to the problem.

After a few conversations with their team, we knew it was time to make a decision on whether we should continue to build or buy this technology. On one side of the scale, they were offering a lot of answers to the quirks we saw with the Docker CLI and installation process. On the other end, we had already gotten this far. The team at Replicated wassuper open to non-committal prototyping in their system, so we did a quick prototype of our application within their platform. It didn’t take long to see that it abstracted away a lot of the complexity of our original enterprise product.

Instead of VIMing a config file, our customers could run an install script and configure their instance with a simple settings interface. We could ship Plotly to almost any environment that allowed Docker to be installed. We knew our technical sales team would be able to help our customer get Plotly On-Premise installed using this system. Finally, the roadmap for the team at Replicated is 100% focused on enabling this enterprise experience as well as extending applications on the platform with additional enterprise functionality (stuff like LDAP, audit logs etc. that we have little interest in building). So we took the plunge.

Shipping to Customers

Our next major release for Plotly On-Premise was powered by Replicated. We started noticing features that were saving us time and energy. Supporting customers before Replicated involved a lot of back and forth. While this still isn’t a completely solved problem even with Replicated, they have built out tooling that allows our customers to send us an auto-generated support bundle that contains all the log files associated with their instance.

Our customers also were noticing a better experience. Not only was the installation much simpler, but managing the application became much easier. We were able to build a lot of the deployment & management knowhow into the development effort by using their (fairly rudimentary at the time) scheduling & orchestration system. As a result, our enterprise customers don’t have to be familiar with Docker; it just works. With other features like automatic backups, we no longer had to instruct our enterprise customers how to manually backup their instance, while keeping our fingers crossed that they actually did it.

Plotting forward

We can now quickly spin up enterprise trials, proving to customers that Plotly works in their environment and putting our product front and center. Most importantly, we no longer need to treat deployments as a core feature, allowing us to spend more time and energy on making Plotly the best modern platform for agile business intelligence and data science.

For more information on Plotly On-Premise or to set up a trial, visit our product page.

You can’t right now, but we’re planning on building an “upload” component.

> Can I use sklearn or other non-standard packages?

Yup! You can use whatever packages you want in your backend. Dash places no restrictions on what types of what packages you use in your callback functions.

Dash is a Open Source Python library for creating reactive, Web-based applications. Dash started as a public proof-of-concept on GitHub 2 years ago. We kept this prototype online, but subsequent work on Dash occurred behind closed doors. We used feedback from private trials at banks, labs, and data science teams to guide the product forward. Today, we’re excited to announce the first public release of Dash that is both enterprise-ready and a first-class member of Plotly’s open-source tools. Dash can be downloaded today from Python’s package manager with pip install dash — it’s entirely open-source and MIT licensed. You’ll find a getting started guide here and the Dash code on GitHub here.

Dash is a user interface library for creating analytical web applications. Those who use Python for data analysis, data exploration, visualization, modelling, instrument control, and reporting will find immediate use for Dash.

Dash makes it dead-simple to build a GUI around your data analysis code. Here’s a 43-line example of a Dash App that ties a Dropdown to a D3.js Plotly Graph. As the user selects a value in the Dropdown, the application code dynamically exports data from Google Finance into a Pandas DataFrame. This app was written in just 43 lines of code (view the source). Simple.

Dash app code is declarative and reactive, which makes it easy to build complex apps that contain many interactive elements. Here’s an example with 5 inputs, 3 outputs, and cross filtering. This app was composed in just 160 lines of code, all of which were Python.

Every aesthetic element of the app is customizable: The sizing, the positioning, the colors, the fonts. Dash apps are built and published in the Web, so the full power of CSS is available. Here’s an example of a highly customized, interactive Dash report app, in the brand and style of a Goldman Sachs report.

While Dash apps are viewed in the web browser, you don’t have to write any Javascript or HTML. Dash provides a Python interface to a rich set of interactive web-based components.

import dash_core_components as dcc

dcc.Slider(value=4, min=-10, max=20, step=0.5,
           labels={-5: '-5 Degrees', 0: '0', 10: '10 Degrees'})

Dash provides a simple reactive decorator for binding your custom data analysis code to your Dash user interface.

@dash_app.callback(Output('graph-id', 'figure'),
                   [Input('slider-id', 'value')])
def your_data_analysis_function(new_slider_value):
    new_figure = your_compute_figure_function(new_slider_value)
    return new_figure

When an input element changes (e.g. when you select an item in the dropdown or drag a slider), Dash’s decorator provides your Python code with the new value of the input.

Your Python function can do anything that it wants with this input new value: It could filter a Pandas DataFrame, make a SQL query, run a simulation, perform a calculation, or start an experiment. Dash expects that your function will return a new property of some element in the UI, whether that’s a new graph,a new table, or a new text element.

For example, here’s a simple Dash application that updates a text box as you interact with the Graph element. The application code filters data in a Pandas DataFrame based off of the currently selected point.

This Dash application displays meta information about drugs as you hover over points in the Graph component. The application code also appends rows to the Table component when elements are added to the multi Dropdown component.

component.

Through these two abstractions — Python components and reactive functional decorators — Dash abstracts away all of the technologies and protocols that are required to build an interactive web-based application. Dash is simple enough that you can bind a user interface around your Python code in an afternoon.

Architecture

Flask and React

Dash applications are web servers running Flask and communicating JSON packets over HTTP requests. Dash’s frontend renders components using React.js, the Javascript user-interface library written and maintained by Facebook.

Flask is great. It’s widely adopted by the Python community and deployed in production environments everywhere. The underlying instance of Flask and all of its configurable properties is accessible to Dash app developers. For advanced developers, Dash apps can be extended through the rich set of Flask Plugins as well.

React is fantastic too. At Plotly, we’ve rewritten our entire web-platform and our online chart editor with React. One of the incredible things about React is how prolific and talented the community is. The open source React community has published thousands of high quality interactive components, from Dropdowns to Sliders to Calendar Pickers to Interactive Tables.

Dash leverages the power of Flask and React, putting them to work for Python data scientists who may not be expert Web programmers.

From React.js to Python Dash Components

Dash components are Python classes that encode the properties and values of a specific React component and that serialize as JSON. Dash provides a toolset to easily package React components (written in Javascript) as components that can be used in Dash. This toolset uses dynamic programming to automatically generate standard Python classes from annotated React propTypes. The resulting Python classes that represent Dash components are user friendly: They come with automatic argument validation, docstrings, and more.

Here’s an example of the dynamically generated argument validation:

>>> import dash_core_components as dcc
>>> dcc.Dropdown(valu=3)
Exception: Unexpected keyword argument `valu`
Allowed arguments: id, className, disabled, multi, options, placeholder, value

and an example of the dynamically generated component docstrings:

>>> help(dcc.Dropdown)
class Dropdown(dash.development.base_component.Component)
 |  A Dropdown component.
 |  Dropdown is an interactive dropdown element for selecting one or more
 |  items.
 |  The values and labels of the dropdown items are specified in the `options`
 |  property and the selected item(s) are specified with the `value` property.
 |
 |  Use a dropdown when you have many options (more than 5) or when you are
 |  constrained for space. Otherwise, you can use RadioItems or a Checklist,
 |  which have the benefit of showing the users all of the items at once.
 |
 |  Keyword arguments:
 |  - id (string; optional)
 |  - className (string; optional)
 |  - disabled (boolean; optional): If true, the option is disabled
 |  - multi (boolean; optional): If true, the user can select multiple values
 |  - options (list; optional)
 |  - placeholder (string; optional): The grey, default text shown when no option is selected
 |  - value (string | list; optional): The value of the input. If `multi` is false (the default)
 |  then value is just a string that corresponds to the values
 |  provided in the `options` property. If `multi` is true, then
 |  multiple values can be selected at once, and `value` is an
 |  array of items with values corresponding to those in the
 |  `options` prop.
 |
 |  Available events: 'change

The full set of HTML tags, like <div/>, <img/>, <table/> are also rendered dynamically with React and their Python classes are available through the dash_html_component library. A core set of interactive components like Dropdown, Graph, Slider will be maintained by the Dash core team through the dash_core_components library. Both of these libraries use the standard open-source React-to-Dash toolchain that you could use if you were to write your own component library.

You’re not tied to using the standard Dash component library. The Dash component libraries are imported separately from the core Dash library. With the React-to-Dash toolchain, you can easily write or port a React.js component into a Python class that can be used in your Dash application. Here’s the tutorial on building your own components. Or, the Dash core team can build one for you.

Concurrency — Multi-User Applications

The state of a Dash application is stored in the front-end (i.e. the web browser). This allows Dash apps to be used in a multitenant setting: Multiple users can have independent sessions while interacting with a Dash app at the same time. Dash application code is functional: Your application code can read values from the global Python state but it can’t modify them. This functional approach is easy to reason about and easy to test: It’s just inputs and outputs with no side-effects or state.

CSS and Default Styles

CSS and default styles are kept out of the core library for modularity, independent versioning, and to encourage Dash App developers to customize the look-and-feel of their apps. The Dash core team maintains a core style guide here.

Data Visualization

Dash ships with a Graph component that renders charts with plotly.js. Plotly.js is a great fit for Dash: it’s declarative, open source, fast, and supports a complete range of scientific, financial, and business charts. Plotly.js is built on top of D3.js (for publication-quality, vectorized image export) and WebGL (for high performance visualization).

Dash’s Graph element shares the same syntax as the open-source plotly.py library, so you can easily to switch between the two. Dash’s Graph component hooks into the plotly.js event system, allowing Dash app authors to write applications that respond to hovering, clicking, or selecting points on a Plotly graph.

Open Source Repositories

You can check out the code yourself across a few repositories:

• Dash backend: https://github.com/plotly/dash
• Dash frontend: https://github.com/plotly/dash-renderer
• Dash core component library: https://github.com/plotly/dash-core-components
• Dash HTML component library: https://github.com/plotly/dash-html-components
• Dash component archetype (React-to-Dash toolchain): https://github.com/plotly/dash-components-archetype
• Dash docs and user guide: https://github.com/plotly/dash-docs, hosted at https://plot.ly/dash
• Plotly.js — the graphing library used by Dash: https://github.com/plotly/plotly.js

Prior Art

Dash is new in the Python ecosystem but the concepts and motivation behind Dash have existed for decades in a variety of different languages and applications.

If you’re coming from Excel, then your head is in the right place. Both Dash and Excel use a “reactive” programming model. In Excel, output cells update automatically when input cells change. Any cell can be an output, an input, or both. Input cells aren’t aware of which output cells depend on them, making it easy to add new output cells or chain together a series of cells. Here’s an example Excel “application”:

There’s an Excel analogy for Dash. Instead of cells, we have rich web based components like sliders, inputs, dropdowns, and graphs. Instead of writing Excel or VBA script, we’re writing Python code. Here is that same spreadsheet application, rewritten in Dash:

app.layout = html.Div([
    html.Label('Hours per Day'),
    dcc.Slider(id='hours', value=5, min=0, max=24, step=1),

html.Label('Rate'),
    dcc.Input(id='rate', value=2, type='number'),

html.Label('Amount per Day'),
    html.Div(id='amount'),

html.Label('Amount per Week'),
    html.Div(id='amount-per-week')
])

@app.callback(Output('amount', 'children'),
              [Input('hours', 'value'), Input('rate', 'value')])
def compute_amount(hours, rate):
    return float(hours) * float(rate)

@app.callback(Output('amount-per-week', 'children'),
              [Input('amount', 'children')])
def compute_amount(amount):
    return float(amount) * 7

I like this example a lot because Excel still reigns supreme, even in technical computing and quantitative finance. I don’t think that Excel’s dominance is just a matter of technical ability. After all, there are legions of spreadsheet programmers who have learned the nuances of Excel, VBA, and even SQL.

It’s more that Excel spreadsheets are frequently easier to share than Python programs, and Excel cells are easier to edit than command line arguments.

Yet modelling in Excel has well-known limits: These spreadsheets often outgrow themselves. They become too large or fragile to migrate into a production environment, peer review, test, and maintain. Remember the 2013 pro-austerity Excel typo?

I hope that Dash makes it easier for developers to use Python for their data projects. By sharing the same functional and reactive principles, it’s almost as easy to write a Dash app as it is to write an analytical spreadsheet. It’s certainly more powerful and presentable.

If you develop in the R programming language, you’re in luck. Shiny is a reactive programming framework for generating web applications in pure R. It’s great! You can even create interactive graphics with Shiny and Plotly’s R library. Dash and Shiny are similar but Dash does not aim to be a replica of Shiny. The idioms and philosophies between Python and R are different enough to warrant a different syntax.

If you program in MATLAB then you may be familiar with MATLAB’s user interface library “GUIDE”. Mathworks was one of the true original innovators in technical computing — GUIDE was written in 2004, 13 years ago!

If your data is structured in a database, then you may be using Tableau or one of the other BI tools. Tableau is incredible. They’ve set a new expectation in the industry that end-users should have the autonomy and the tools to be able to explore their organization’s data. They’ve also helped popularize the concepts of “drilling down” and cross-filtering.

Dash is complementary to BI tools like these. These tools work great for structured data. But when it comes to data transformation and analytics, it’s hard to beat the breadth and flexibility of programming languages and communities like Python. Dash abstracts away a lot of the complexities in building user interfaces, enabling you to build a beautiful front-end for your your custom data analytics backend.

Finally, I’d like to give a shout out to Jupyter widgets. Jupyter provide a really nice widget framework inside their notebook interface. You can add sliders to your graphs in the Jupyter notebooks that you run locally.

The widgets in Dash are similar to the widgets in Jupyter. In Jupyter Notebooks, you can add widgets directly alongside your code. In Dash, your controls and application are kept separately from your code. Dash is aimed more towards sharable apps than it is to sharable code and notebooks. You can always mix-and-match the tools, and write your Dash apps in the Jupyter Notebook environment.

We’re also big fans of the nteract project, which is really lowering the barrier to entry of Python and Jupyter Notebooks by wrapping up Jupyter Notebook as a desktop application.

Licensing and the Open Source Business Model

Plotly is a VC-backed startup. We founded in 2013 and we open sourced our core technology, plotly.js, in 2015 (MIT license). We maintain open source libraries in Python, R, and MATLAB that interface with plotly.js and a web app for creating these charts and connecting them to databases (the connectors are also open source).

We provide subscriptions to our chart hosting and sharing platform, and to our chart editing and database querying app. This platform is available on the web (plot.ly) and on-premise.

We’re applying a similar model to Dash. Dash is MIT licensed. It’s free to use and to modify. For companies, we’re offering Dash Enterprise, a deployment server for easily publishing and provisioning Dash Apps behind your firewall.

Our goal with Dash Enterprise is to make sharing a Dash app internally as easy and secure as possible. No dev-ops required. Dash Enterprise handles the URL routing, the monitoring, the failure handling, the deployment, the versioning, and the package management. Dash Apps deployed with Dash Enterprise can be provisioned through your company’s Active Directory or LDAP user accounts.

If you’re using the open source version locally, there are no restrictions. You can manage deployment of Dash apps yourself through platforms like Heroku or Digital Ocean. If you have the resources, consider purchasing a support plan to get one-on-one help from a Plotly engineer. If you need more specialized help or would like to fund specific feature development, reach out to our advanced development program.

Open source is still a new idea for product companies, yet at the end of the day, we’re able to dedicate more than half of our staff towards open source products. Huge thanks to everyone who has supported us so far ❤️

Thanks for checking out Dash. I’ll be giving a talk about Dash at SciPy this summer in Austin and in next fall at Plotcon NYC. If you’ll be at either of those events, please say hi! Otherwise, I’ll see you on GitHub ✌️🏼

Further Resources and Footnotes

1. Our Dash documentation is hosted at https://plot.ly/dash
2. All of our open source work is in our GitHub organization at https://github.com/plotly
3. If you’d like to fund specialized features, reach out to our Advanced Development team: plot.ly/products/consulting-and-oem/
4. You can find us on Twitter at @plotlygraphs.
5. If you’re looking for inspiration in user interfaces for technical computing, I highly recommend Bret Victor’s essay on What Can A Technologist Do About Climate Change? In particular, the sections on Technical computing and Media for understanding situations
6. Related, if you find the intersect between technical computing and interface interesting, you might like Explorable Explanations
7. You can reach out to me directly at chris@plot.ly or on twitter at @chriddyp

This is in stark contrast to data from late 2013, when the smartphone/tablet vs desktop media consumption battle was very nearly 50%/50%.

Amidst the height of the digital age, sharp mobile graphics are more critical than ever.

So the next time you’re building a Plotly masterpiece, consider using our new “mobile” graph feature. It’s super easy and will ensure that your graphs look as fly on mobile as they will on the 100 inch big screen.

What You Don’t Want Your Graph to Look Like

While the above graph looks fantastic on a laptop or desktop, that’s just a small segment of the potential viewers. Without being touched up using Plotly’s mobile tool, the graph looks about as bad as Donald’s decisions around global warming. Okay, maybe not that bad, but check this out:

But no stress, because in a few screenshots we’ll show you how to finesse that mess into something that’s sure to impress…

1. Under the style dropdown, select “Mobile.”

2. In the “Mobile” menu, select “add a view.”

3. Within your “new (mobile) view,” change the max width. Bear in mind that most mobile devices have a width of 480px or less.

4. Under the style dropdown, select “Layout” then “Canvas.” Make sure your canvas size is set to “Custom” and that your view is “View 1.” Then, change the width of your graph to the same size that you specified in step 3.

5. You’ll notice that our previously added notes look horrid. For crisp graphs on mobile, get rid of them.

6. Back in the “Layout” menu now, we’ve changed the “title and fonts” size. We’ve also erased or significantly shortened our axis labels.

7. You can adjust the “Margins and Padding” to best suit your graph. Typically, 50–50–25–25–0 looks the best on mobile, as pictured below.

8. You’re done. Look how sharp the mobile version looks now, along with an equally sharp desktop version.

But what happens if you tilt your mobile device horizontally to get a better view of a graph?

Watch how responsive Plotly graphs are to such a change 🔮

Plotly is built by computational scientists with degrees and research expertise from McGill, Harvard, Stanford, and other world-class institutions. Making no-compromise open-source software for scientific visualization is our full-time job and passion. Want to support our work? Consider purchasing a Pro plan. For less than half the cost of a Tableau license, you’ll get support from our engineering staff and time-saving ways to save and share your work with colleagues, advisors, or managers.

Pro Plans for University students and instructors ($59/year)

Pro Plans for industry users ($396/year)

If a television series has pulled off the latter, it is (at best) fighting an uphill battle and, at worst, on its way off the air.

These critical junctures occur frequently in the world of TV entertainment, but the moment when a television show attempts to draw attention to or create publicity for something that is perceived as not warranting the attention it is known as “jumping the shark.”

Furthermore, the idiom typically refers to something that is past its peak in quality or relevance and popularity.

In this post, we sift through seasons’ worth of IMDB ratings for various shows that supposedly “jumped the shark,” including The Brady Bunch (1969–1974), Lost (2004–2010), Prison Break (2005–2009), Moonlighting (1985–1989), The X Files (1993-present), Dexter (2006–2013), and The Office (2005–2013).

Motivation for this post stems from articles on TheRichest, RollingStone, and SCREENRANT about TV shows that may have jumped the shark.

The graphs below all feature an image to help identify the TV show. Check out how easy it is to add an image to a graph in Plotly:

Learn how to add images to your charts in Python and R.

1. The Brady Bunch

Here’s what TheRichest had to say about The Brady Bunch and its rating fallout:

During the fifth season, Cousin Oliver was brought in as a member of the family. It was seen as such a big shark-jumping moment that it even caused a new term to be coined. “Cousin Oliver Syndrome” is known as what happens when a show brings in a new character to re-attract fans, and the gimmick didn’t pay off: after just six episodes, Cousin Oliver was removed from the show.

2. Lost

Lost is an interesting case. The rating trend a flat line through the whole series, but still the show is considered a shark jumper by RollingStone:

No one agrees when exactly Lost lost its mojo, because there is no one JTS moment that stands above the rest. Was it when the survivors met the Others and they didn’t make any sense? Or when the infamously annoying Nikki and Paulo materialized on the scene? Or when Claire got amnesia? Or when the Island traveled back in time? Or when Locke was resurrected? Or when it turned out that all the evil in the world was being held back by a literal cork? Or when… The point is, Lost disappointed us at least as many times as it bowled us over.

3. Prison Break

Prison Break exhibited a steep decline in show ratings over the course of its 4 season run. SCREENRANT declared it a shark jumper:

Another high-concept show of the 2000s, Prison Break was another instant hit. The story of the two brothers, one sentenced to death for a crime he did not commit, and the other who devises an elaborate plan to help his brother escape prison and clear his name drew in big audiences. At the end of the first season, the brothers, along with several others, escape in a tunnel dug beneath the walls of the prison.

The second season followed a very different format and met with mixed reactions. Some praised the change in direction, feeling that they couldn’t stay in the prison forever. Others felt that the show had become too different to the original formula and had become a show about fugitives as opposed to prisoners. At the end of season 2, several prisoners were recaptured and imprisoned in Panama.

Despite running for a further 2 seasons, most viewers agreed that the show declined in quality sometime during season 2.

4. Moonlighting

Moonlighting was the definitive will-they-won’t-they show, with most of the attention being given to the chemistry between co-stars Bruce Willis and Cybill Sheppard. The show was a mixture of drama, comedy, and romance, and was considered to be one of the first successful examples of comedy-drama, or “dramedy.”

Despite being a massive hit, once the two leads entered into a relationship, the show was in trouble. While the investigations of the private detective agency had been central to the show, along with successful gimmicks such as their “breaking the fourth wall,” the main audience draw was waiting for the couple to give in to the sexual chemistry between them.

When the couple finally got together in season 3, there were behind the scenes complications which added to the shows problems. Cybill Sheppard was off having twins, so they had to shoot her scenes in advance, causing much fewer scenes with her and Bruce Willis. Also, Willis was making Die Hard. When that was a massive success, his interest in making a weekly show waned, due to his blooming movie career.

-SCREENRANT

5. The X Files

In a way, the fact that this show named one of their episodes “Jump the Shark” says it all. If you have to name an episode of your show that, it’s a pretty big example of self-realization. You could use several episodes as examples as to how The X-Files tried desperately to regain the luster it once had, but the most obvious ones are probably through their first movie in 1998, or the episode where Mulder leaves following the seventh season. To break up one of the most distinctive pairings on TV is a bold move, and one that didn’t exactly pay off the way The X-Files’ producers had hoped.

-TheRichest

6. Dexter

Au revoir, unholy Trinity (Season 4, Episode 12)
Facile argument: Dexter was ruined the moment its second season revealed itself, early on, as a weak re-brew of everything those first 12 episodes had so beautifully concocted. (Kill, cover-up, stalk worse killer, rinse, repeat.) But the true shark-leap was the moment that distinguished gentleman actor John Lithgow was knocked off at the end of Season Four. Many memorable stars came and went in Showtime’s serial-murderer drama, but in his single-season run as the Trinity Killer, Lithgow repeatedly stole the show — and then was forced to vacate it (at the same time as some crucial co-stars), leaving a huge void in his wake. You knew it was coming, yet the series never really recovered from the loss, and only worsened in its damnably formulaic approach as it bled out over four more long seasons.

-RollingStone

7. The Office

Jim and Pam tie the knot (Season 6, Episode 4)
In its heyday, Greg Daniels’s mockumentary sitcom was one of the best comedies on television, balancing cringe comedy and sweet-natured character studies. But that perfect blend began to sour around the same time as those crazy kids Jim and Pam finally got hitched; they consequently morphed into being annoying jerks, and we lost our audience surrogates into this world of socially delayed salesmen and bumbling accountants. The stakes became so low that the show had to start jumping through hoops, and the cringe humor became just plain cringeworthy. By the time the show’s boss Michael Scott (and Steve Carell) departed for greener pastures, The Office was already a shell of its former self.

-RollingStone

An example of a show that never jumped the shark:

Bates Motel

A recently completed series, Bates Motel, is a prime example of a show that brought just the right amount of suspense and surprise without doing the shark jump. The ratings below speak for themselves.

Plotly is built by computational scientists with degrees and research expertise from McGill, Harvard, Stanford, and other world-class institutions. Making no-compromise open-source software for scientific visualization is our full-time job and passion. Want to support our work? Consider purchasing a Pro plan. For less than half the cost of a Tableau license, you’ll get support from our engineering staff and time-saving ways to save and share your work with colleagues, advisors, or managers.

Pro Plans for University students and instructors ($59/year)

Pro Plans for industry users ($396/year)

Hooray! 🎉 Thanks to Medium’s integration with Embedly, Medium now supports embedded Plotly graphs! You wouldn’t believe how easy it is - all you have to do is drop your Plotly graph link in Medium’s text editor. A win-win for Medium users and graph lovers alike — now give your data narratives more interactive context and click-ability. Watch how easy it is:

To celebrate, we share seven of Plotly’s top, can’t-miss graphs that have withstood the test of time.

These particular graphs have been picked from Plotly user Dreamshot. “Dreamshot” has created 1000s of graphs that have been used in Plotly blog posts, tutorials, mock-ups, demos, and slide decks.

Gender Ratio and Age on Dating Sites

This one confirms your suspicions. At the age of 23 (the peak age for online dating), there are 2.5 men for every 1 woman on dating sites.

Men’s Facial Hair Trends

The data used to make this graph is drawn from a paper on shaving trends. The author concludes that the “dynamics of taste”, in this case facial hair, are“common expressions of underlying conditions and sequences in social behavior.”

Climate Change Attribution

From the source:

“One global climate model’s reconstruction of temperature change during the 20th century as the result of five studied forcing factors and the amount of temperature change attributed to each.”

Age of Nobel Prize Winners by Field

In 2014 Malala Yousafzai won the Nobel Peace Prize, making her the youngest winner in history. She is an outlier in this box plot with jitter. The plot shows the age when Nobel Laureates received their prize. See our full post to learn more.

Per Capita Consumption of Tobacco in the U.S.

This plot was published in an academic journal then used in a Vox article on tobacco. Vox points out that after 1890, “Cigarettes only went from niche product to mass-market success after the rolling machine improved dramatically.”

The Formative Years

The Upshot, a New York Times blog, publishes articles and data visualizations about politics, policy, economics, and everyday life. The visualization below comes from a study of political opinions. Events that occur between the ages of 14–24 are most impactful for the voting patterns and political preferences of the next generations of voters.

Great Achievements at Young Ages

Recognition delay is increasing across fields. According to the authors:

“The increasing number of scientists, their increasing life expectancy, changing research and career policies, and so on, must all play a role in the delay.”

Yes they are! For example using WebGL, Plotly.js’s pointcloud scatter does 1 millions+ points with @plotlygraphs http://codepen.io/monfera/pen/BLjJVZ or Plotly.js parcoords does 100k lines

> They lack key chart types (e.g. parallel axis charts)

Parallel Coordinates Plot

Many more publication-quality, high-performance chart types at:

https://plot.ly/javascript/

> They are not easily extendable when we need to add or enhance features

Plotly.js has dozens of community contributors that have read the open-source codebase and enhanced the library through GitHub:

https://github.com/plotly/plotly.js/pulls

A brief introduction: I’m Ben Noll (https://twitter.com/BenNollWeather), a meteorologist for the National Institute of Water and Atmospheric Research in New Zealand. I routinely make short-term weather forecasts (minutes to weeks) and climate projections (seasonal to annual time scales).

The weather is something that never goes out of style: it affects all of us every day, in one way or another. You may not think of it much during the long stretches of dry and sunny weather during the summer and autumn — but when you get an unexpected 10 minute shower during your picnic, curse the weatherman!

I get it. It comes with the territory. But I assure you: weather (and climate) forecasting is far more accurate than it was even 10 years ago. We’ve come a long way. But as with all crafts, we have room to improve, particularly when it comes to communication (of extremes).

The plot above shows something called anomaly correlation — just a fancy phrase that implies weather model skill — for the world’s three most accurate weather models. It may seem a bit noisy, but here’s the takeaway: since the start of the time series (2010), all three models have a positive (skill) trendline.

When Yale recently released its Climate Opinion Maps describing the “geographic variation in opinions on climate change at state and local scales in the USA,” I felt it would be an ideal creative outlet and also a chance to make some killer content for Plotly.

At the same time, I thought it would be an excellent opportunity to share some projections for later in 2017 and how it might affect the Earth’s weather, climate and you.

1. What is Climate Change and Global Warming?

Climate change, according to NASA, is a change in the typical or average weather of a region or city and/or Earth. Not only is this phrase associated with a warming Earth, but also changing precipitation patterns, sea levels, sea ice, and more.

One of the largest components of our changing climate is global warming, or referring to surface temperature increases from both natural (El Niño) and anthropogenic (greenhouse gases) causes. There’s no denying that we live on a warming Earth. Land temperatures are modulated by sea temperatures, which are also rising. Both are being influenced by carbon pollution, which continues to break records year after year. The monthly average carbon dioxide concentration for March 2017 was 407 parts per million (ppm).

Seven in ten Americans think global warming is occurring. One in ten does not.

Are human activities the main cause?

There’s no denying the distinctive, positive relationship between global temperatures and atmospheric carbon dioxide concentration. Some individuals that are not in favor of anthropogenic climate change refer to warming oceans as the guiding hand for increased global temperatures. Warming oceans certainly play a large role, but it begs the question: why are ocean temperatures warming?

While the Earth’s climate has exhibited marked “natural” changes, with time scales varying from many millions of years down to a few years, the recent warming is most likely attributable to carbon pollution. Furthermore, El Niño events, which I’ll cover in more detail further down, are associated with semi-permanent upward steps in global temperatures, initially caused by a warming of sea surface temperatures in the eastern and central equatorial Pacific Ocean. Research has shown that El Niño events may be increasing in frequency due to human-induced climate change.

States that are most convinced that global warming is caused by human activities:

1. California (59%)
2. Maryland (58%)
3. New York (58%)

States that are least convinced that global warming is caused by human activities:

1. Wyoming (42%)
2. Utah (43%)
3. West Virginia (44%)

Is global warming harming you now or will it within the next 10 years (from 2016)?

A question posed in the Yale survey, residents of New York (57%), California (56%), and Maryland (55%) had the most bullish opinion in the “yes” direction. On the other hand, North Dakota (39%), Wyoming (39%), and West Virginia (40%) weren’t as convinced.

While no one weather event is caused by climate change, all events are influenced by climate change since the atmosphere is now warmer and moister than it was in the past. Climate change increases the likelihood of extreme rainfall, given the appropriate weather setup. Research suggests that there will be up to 8% more intense rain for every 1°C of warming.

Since averages are a product of the extremes and extremes are expected to increase in the coming decades, it may involve more impactful tropical cyclones. Yale polled 996 resident’s of Connecticut’s coast who live in coastal flood zones and experienced a hurricane or tropical storm previously, asking the question, “generally speaking, when a hurricane or tropical storm is approaching your city or town, how worried do you feel (1–7)?

The results were skewed toward the mid-upper part of the scale, with “5” receiving 22% of the vote. Since a warmer climate will hold more water vapor, climate change indirectly yield more concern and worry amongst coastal residents when it comes to tropical storms and hurricanes.

Natural Influences

El Niño, a climate driver associated with a band of warm ocean water that develops in the central and east-central equatorial Pacific, has been associated with semi-permanent upward step changes in global temperature during and following the “event.” An El Niño event typically takes 3–6 months to develop, reaches a peak during November to January, and then declines for the following 3–6 months. The temperature rises associated with El Niño events have been disproportionate to the temperature falls during the opposite climate driver, La Niña.

The natural effects from El Niño events are likely enhanced by greenhouse gas emissions, or the anthropogenic warming that continuously works in the background. And the impact(s) from El Niño events may not be entirely natural anymore — research indicates that there may be an increasing frequency of extreme El Niño events due to greenhouse warming.

Global climate modeling is now suggesting that another El Niño event is possible later in 2017, in very quick succession to the strong El Niño that occurred during 2015–16.

Such an outcome would result in yet another upward step in global temperatures, but starting from the new “baseline” that was established by the super El Niño observed during 2015–16.

Trump not fussed

During his first two months in office, U.S. President Trump rolled back key Obama-era greenhouse gas regulations. Without these rules in place, the United States will likely fall far short of its 2015 Paris Agreement pledge: to lower emissions by at least 26 percent below 2005 levels by 2025.

“Mr. Trump instructed the Environmental Protection Agency to reverse course on the Obama administration’s biggest climate change policy, the Clean Power Plan, which aimed to cut emissions from existing coal- and gas-fired power plants,” writes Nadja Popovich of the New York Times.

If implemented to its fullest extent, the plan would have reduced carbon emissions by nearly 650 megatons by 2025 — just under halfway to the Paris pledge, according to an analysis by Climate Interactive.

In the meantime, as global temperatures continue to rise, so will the number of “hot days” and likelihood for heat waves. For some, winters will become milder and the growing season longer. However, it goes well beyond just warmer temperatures — but how ecosystems will cope and respond, how we grow our food, and where and when we get our water. All those things will change, some more gradually than others.

With respect to Earth’s lifeforms, the words cope and adapt may have never been more relevant. For those that can do this most efficiently will best set themselves up for the future on the ever-changing planet that we call home.

Plotly is built by computational scientists with degrees and research expertise from McGill, Harvard, Stanford, and other world-class institutions. Making no-compromise open-source software for scientific visualization is our full-time job and passion. Want to support our work? Consider purchasing a Pro plan. For less than half the cost of a Tableau license, you’ll get support from our engineering staff and time-saving ways to save and share your work with colleagues, advisors, or managers.

Pro Plans for University students and instructors ($59/year)

Pro Plans for industry users ($396/year)

Bioinfo-what?! At Plotly, we’re proud of our diverse and talented user base. In this post, we show off the work of our bioinformaticians.

In case you didn’t know:
Bioinformatics is an interdisciplinary field that develops methods and software tools for understanding biological data. As an interdisciplinary field of science, bioinformatics combines computer science, statistics, mathematics, and engineering to analyze and interpret biological data.

Plotly happens to serve a large bioinformatics and biostats research community. These users leverage the uniquely interactive features of Plotly charts for dendrograms, heatmaps, volcano plots, and other visualizations common in this field.

In this post, we show off 7 resources in Python and R created by Plotly bioinformatics and biostats researchers by way of a Spectacle Editor presentation. You can make a similar presentation with your Plotly graphs.

Presentation

1. Jupyter notebook: Visualizing bioinformatics data with plotly and python

2. Zoom & hover in volcano plots

3. Interactive dendrograms in R & Python

4. Toggle lines and distributions with the legend

5. Take it to the 3rd dimension

6. Interactive Manhattan Plots

7. Gene Expression Heatmaps

Plotly is built by computational scientists with degrees and research expertise from McGill, Harvard, Stanford, and other world-class institutions. Making no-compromise open-source software for scientific visualization is our full-time job and passion. Want to support our work? Consider purchasing a Pro plan. For less than half the cost of a Tableau license, you’ll get support from our engineering staff and time-saving ways to save and share your work with colleagues, advisors, or managers.

Pro Plans for University students and instructors ($59/year)

Pro Plans for industry users ($396/year)