Flávio Juvenal

Web developer from Brazil. Loves beautiful high-quality products, from UX to code, and will defend them against unreasonable deadlines and crazy features. Partner at Vinta (https://www.vinta.com.br/), a web consultancy specialized in building products with React and Django.

Speaker home page

Preventing headaches with linters and automated checks

Fundamentals, Intermediate
8/13/2017 | 10:00 AM-11:00 AM | Here


This talk will teach you how to use and extend tools for automated checks on Python projects. Are your imports a mess? No reasonable order, stdlib modules mixed with third-party ones? There's a tool to fix that. Tired of checking for security patches of the libs in your requirements.txt? Let a tool do this for you. We'll learn about many other tools and we'll also discuss how to build new ones.


While it's very common to enforce PEP8 code style with tools like pycodestyle or flake8, it's rare for Python projects to use other types of tools for automated checks. However, there are many common problems in readability, security, configuration, etc that could be avoided by using other linters and tools, for example:

  • Are your imports a complete mess, with third-party modules mixed with stdlib ones? You can use "isort" to organize and separate them.
  • Tired of checking if your project requirements received security patches? Let "safety" do that for you.
  • Hated when that fellow developer pushed a huge file that slowed your repository pulls forever? A "pre-commit" hook with a simple check could've prevented that.
  • Is your code cluttered with unused legacy functions and classes? Check and prevent that with "vulture".

As we can see from the list above, many issues can be prevented at commit or CI time with automated tools. In this talk, we'll discuss how to configure and use those tools. Also, we'll learn the role of static analysis in those tools, which will enable us to extend them and build new ones.

Here is a non-exhaustive list of tools that will be presented:

  • prospector: https://github.com/landscapeio/prospector
  • pylint: https://github.com/PyCQA/pylint
  • safety: https://github.com/pyupio/safety
  • bandit: https://github.com/openstack/bandit
  • pre-commit: http://pre-commit.com/
  • isort: https://github.com/timothycrosley/isort
  • vulture: https://github.com/jendrikseipp/vulture
  • pycycle: https://github.com/bndr/pycycle
  • pyt: https://github.com/python-security/pyt
  • Django System check framework: https://docs.djangoproject.com/en/1.10/ref/checks/

Your Django app is a User Interface

All things web, Intermediate
8/12/2017 | 3:15 PM-4:15 PM | Fisher East


Usability heuristics are a useful way to evaluate an interface. An often overlooked aspect of Django apps is they’re interfaces too, one that connects the developer with a reusable solution. In this talk, we’ll learn how to apply usability concepts to Django apps to make them better to (re)use.


Django docs say "Reusability is the way of life in Python. You only need to write the parts that make your project unique". The Django way to write reusable code is Django apps, which are straightforward to write. The vast quantity of apps available in PyPI and Django Packages proves that.

However, there is one overlooked aspect of apps: they are an interface between the developer and a reusable solution for a problem. Therefore, as any interface, Usability Heuristics should be used to evaluate Django apps efficacy. In this talk, we'll learn how to apply Usability Heuristics to Django apps to make them better to (re)use.

Talk outline:

  • Unix Philosophy and Django apps concept

  • Aesthetic and minimalist design

  • How to design for the 90% use case
    • Progressive disclosure and Affordance
    • Docs first
  • How to write beautiful app code with declarative programming
  • How to write simple app code by minimizing state

  • Consistency and Recognition rather than recall

  • How common Django idioms increase recognition
  • How existing Django abstractions help increase recognition
  • How separating concerns with Django abstractions increase recognition

  • Flexibility and efficiency of use

  • How making the other 10% use case possible with an extensible granular API
  • The concept of Integration Discontinuity
  • How to break Django abstractions to increase extensibility
  • How a granular API allows composition of apps

  • Error prevention and recovery

  • How to use Django system check framework to prevent errors and give tips
  • How to fail-fast if an error occurs, preventing some unexpected state

  • djangoappschecklist.com

  • How the community can help define a good practices checklist