Chloe’s keynote will dive into why laughter, fun, and entertainment are valuable in the world of tech. Speaking from the experience of someone with a 4-year theatre degree who once played a talking crayon on stage (blue AND yellow – she has a wide range), she’ll dive into lessons learned from theatre applied to engineering.
Unit tests focus on classes and methods while integration tests focus on components and basic business logic. However, neither of these is executed against the full system environment nor take account of the system’s behaviors as a whole. Therefore, our app will not be assured to work properly in production environments if we limit our testing approach to only two types of tests. Incorporating BDD testing into our app’s testing plan addresses these limitations.
BDD is experiencing increasing industry adoption but can still prove daunting to implement from scratch. Our talk will describe how we implement a BDD framework stack by answering following questions:
How do we design structured and reusable test code for BDD?
How do we integrate BDD tests with our CI/CD pipeline?
How do we speed up the execution of BDD automated tests?
How do we set up our BDD framework?
What are the limits of BDD testing?
Django is a robust framework that can handle a lot of complex problems. However, if your goal is to get a simple marketing website up and running, it can be a little too complicated - especially for beginners who are new to frameworks. The admin itself can also appear clunky and confusing to users, and the path to creating a new type of page is paved with views, urls, templates and more!
Wouldn’t it be nice to have an intuitive UI for the admin, and a quick, templated way to create pages in just a few lines of code?
Enter Wagtail - a simple, yet elegant, content management system. With a beautiful admin (great for your clients), a Page class that abstracts things like url structures and views (great for beginners) and built-in WYSIWYG page models (great for on-the-fly content customization), you can focus on getting a flexible site up and running while still having the power of Django to solve complex problems (like querying) when you need it.
This talk will teach you the basics of how Wagtail can save you time and effort by not re-inventing the CMS wheel. It’s aimed at anyone who wants a more user-friendly, out-of-the-box CMS, whether you’re a beginner who is struggling to grasp the concepts of a framework or a seasoned developer looking to streamline this aspect of your project.
As teams and projects grow, code review becomes increasingly important to support the maintainability of complex codebases. In this talk, I’ll cover guidelines for writing consistent python code beyond pep8, how to look out for common python gotchas, and what python tools are available to automate various parts of the review process. Most importantly, I’ll cover the human aspect of code reviews - how we can be better at approaching reviews with empathy and understanding from the perspective of both a reviewer and a submitter. Following these successful code review practices will lead to happier teams and healthier code bases.
At our company, we have faced a monumental task: designing a simple framework for data scientists to create powerful, dynamic web applications using only Python. In order to utilize the power of our machine-intelligence platform, we need to be able to quickly generate web applications to cater to different client solutions. We wanted to move standard data analysis workflows out of the command line, and into sleek, modern web apps that allow for dynamic construction of charts, tables, and other visualizations.
Our talk will focus on how we addressed this problem statement with the development of an application framework built on Django, Channels, and React. We picked these technologies for several reasons. Django is already an incredibly powerful web framework, and we realized very early on that we could use Django Models, Forms, and Form Validation to serve as the core of our backend. However, we opted to take a different approach than server-side rendering, and opted to utilize React on the frontend to display large trees of dynamically-generated components.
To connect these two segments, we decided to use websockets, via Django Channels. Our machine intelligence platform is incredibly powerful, and it allows us to perform tasks on big data with long-running jobs, such as topological modeling, auto-group generation, and feature selection. We use Channels as a way for the Django server to notify the React client on updates to these processes and to refresh different charts and tables.
Lastly, we designed our own Python SDK to allow data scientists to easily generate Python objects which are serialized and converted into React components. A developer using this framework doesn’t need to know Django, React, or Channels, but can utilize the power of all three in concert to quickly prototype powerful machine-learning applications with appealing user interfaces.
Throughout this talk, we will focus on how these technologies interact with one another, the benefits of these design-choices, and the challenges that we faced. The potential applications of this architecture extend far beyond our solutions, and it’s valuable for listeners to understand how Django can be used outside of traditional contexts. Hopefully this talk will inspire other Django developers to consider how their apps can utilize websockets, client-side rendering, and other web-development paradigms to address different and unique use-cases.
This talk will provide a practical look at how Outreachy used a combination of technical and social tools to motivate participants to complete our internship application process. Web developers who work on websites that encourage people to complete tasks will benefit from understanding the social incentive tools presented in this talk. Parts of the talk will be suitable for Django beginners who have completed one Django tutorial and are familiar with the basic concepts of models, objects, views, and templates. Everyone will appreciate the cat photos.
If you’ve never used it before, Docker can be a little overwhelming. There is new vocabulary to learn, new commands to memorize, and new files to add to each project. Most resources fall into one of two camps: they teach you the bare bones of Docker but still leave you with too many questions to comfortably try it on your own, or they throw you into the deep end by assuming you’re more familiar with Docker than you are.
In this talk, you will find that middle ground: a talk that doesn’t assume you’re familiar with Docker and so keeps everything simple, but leaves you with enough information that you can get started as soon as you leave the room. Together, we will step through the parts of a Dockerfile and learn what they do. Then, I’ll introduce you to Docker Compose and explain why using it to run multiple containers is helpful. Finally, you will learn to run commands and execute scripts from the command line using Docker, how to enter a container and why you might need to, and what to do before you go home for the day.
Audience: Djangonauts who are curious about Docker, need to learn to use it for work or personal projects, or who seek a better understanding of containers in general. Audience members might be beginners to Python/Django or not, but they are definitely beginners to containerizing all the things.
The audience should be familiar with basic Python concepts such as variables and running things from the command line. Some basic familiarity with Django would be helpful, but beginner Djangonauts will be able to follow along.
00:00 - Sarah Heim
5:26 - Tim Allen
9:21 - Raphel Michel
13:50 - Katie McLaughlin
15:51 - Simon Willison
21:02 - Griffith Rees
26:18 - Ernist W. Durbin III
30:08 - Flavio Juvenal
35:24 - Filipe Ximens
Tech industry giants are acknowledging that diversity in employee backgrounds is valuable for their organizations’ bottom lines. However, it’s still tough for job seekers to land a tech job without prior experience closely aligned with the job they’re applying for. This talk will focus on helping people who are looking for their next tech role: (1) understand themes of what hiring committees look for, (2) identify transferable skills from nontraditional experience they already have, (3) communicate the power of their unique set of past experiences, and (4) learn tools to demonstrate these skills in their resume and job interviews.
Attendees who are looking for their next role will leave with actionable ideas for improving job application materials, conveying transferable skills from non-technology-related jobs in interviews, and generally rocking any job interview with basic tips that many people miss.
The presenters, both of whom came to tech without a traditional CS background, will give a short introduction of their experience and expertise. They will discuss the aspects of their experience that they expected to be valuable from the start, and those (sometimes surprising!) skills whose value became apparent only after they got to technical positions. Both presenters have participated in hiring panels, one as a hiring manager.
They will share tips and tricks based on industry best practices and their experience reviewing resumes, cover letters, speaking with references, and interviewing job candidates. They will highlight common mistakes and things to consider when applying for, and then interviewing for, attendees’ next tech job.
Docker or more generally, containers, are great for lots of use cases, but they don’t come for free. Container runtimes, network virtualization, orchestration platforms, and registries are all added to the stack. Like all software, they bring their own bugs and operational burden with them. For most Django sites, containers are a heavyweight solution to a lightweight problem.
Despite the overhead, Docker gets a lot of things right. It makes it easy to generate an image of your application in a known state, test the image, pull the image down to your server, apply a specific configuration environment, and run it in a secure sandbox.
But guess what? We can do all that without Docker! Using mostly “boring” software that is already a part of your server or development environment. I’ll walk you through each step of the pipeline and show you how to:
Generate immutable deployment artifacts
Test the artifact
Deploy the artifact
Sandbox your application to improve security
Quickly rollback to a previous version
Task Queues is a topic which most developers will eventually have to dive into, specially in today’s web development world. The idea is really simple: whenever one has any functionality which might take too long to perform, one can spawn a process which will take care of this functionality without having to block the app’s main loop. A task queue will use worker processes to execute these long-running tasks and the user does not have to wait until the task is done. Instead, an acknowledged message is presented to de user while the task is executed in the background. This concept is really important when building web applications. HTTP Requests have timeout and making the user wait a long time for something to finish is not a good user experience practice. Usually, these tasks are used in groups creating a workflow where the work is distributed into smaller tasks.
Celery is usually the first project one encounters when searching for task queues and Django. I have been using Celery for over four years. The Celery project is one of the most robust task queues out there. It is certainly not the only task queue. And, it can be difficult planning the correct architecture for a specific workflow. This talk will explain enough of Celery’s basics to understand how to build workflows with Celery.
Building workflows with Celery is never straight forward. This is mainly because Celery offers the building blocks to build workflows but it tries to move out of the way. By not being too intrusive, Celery allows building complex workflows. I will explain common patters and tips to successfully use celery to build workflow of different complexities.
What are the components in an autonomous vehicle? How do they work with other vehicles and an intelligent infrastructure? In this talk I will cover all the components involved in intelligent infrastructures and how Django is being used in current research.
We have an API whose database schema changes constantly with no need for changes to our code that exposes the data. This is an extremely powerful (but quite possibly a bad) idea. See how we do it!
The Django Admin offers quick solutions and rapid feature development for new websites. But as your website expands, and datasets grow, it can become unwieldy and slow. Enter Elasticsearch: an easy way to quickly accelerate your Django administration tools and searches.
At Grove Collaborative, we’ve experimented with Elasticsearch technology and developed reusable patterns that brought new life to our aging Django administration system. This presentation will teach you how to leverage easy Elasticsearch wins while avoiding common pitfalls.
One of the strengths of Django is that it allows you to use apps created by other developers, so you don’t have to spend time rewriting something that someone else has already written. However, creating Python packages for distribution via the Python Package Index is a process that is unfamiliar to most developers. In this talk, you will learn about creating a reusable Django app. The talk will cover how a Django app differs from a package like requests, and how an app interacts with models and URLs in an existing project.
While the talk will include a discussion of how to upload a Django app to PyPI, the parts that discuss how to make reusable Django apps will be useful to developers who are working at organizations where they may not be able to open-source their code.
This talk is intended for Django developers who have some familiarity with how Django works, and an interest in code reuse and packaging.
The Harry Potter series is an incredibly popular franchise that shaped a generation, but it’s also been critiqued in the media and academics for its sometimes sexist portrayal of female characters. This talk uses Natural Language Processing techniques and Python to do the first quantitative analysis of gender bias in the language used to describe women and girls in the series, with a focus on Hermione Granger, the unsung hero of the story. Attendees will see techniques for reading and parsing large text files, leveraging grammatical rules to isolate the right words for the analysis, and data visualization techniques, using Python, the Natural Language Processing Toolkit (NLTK), and Matplotlib. After the talk, the audience will be able to get started on using the “magic” of programming to isolate biased language in any piece of text.
You have got this super awesome REST API served through Django/DRF based project and suddenly these requirements come in:
We need to have a local support for the Chinese language!
In case, you’ve not written your application with localization and internationalization in mind, then “Boy! You’re in danger! You should better start praying to almighty to give you strength and endurance to support yet another language in your app”.
In this talk, we’ll see how do we support localization and serve our app in different languages, based on what language the client wants to communicate in. As a backend, we should be language agnostic and allow all clients to communicate with us in one of the languages we support.
We’ll see how to support translation for static data (using makemessages / compilemessages) and dynamic data, using various third-party services such as django-translations and transifex.
Here, static data is translations for all the fields, error messages etc. that the app already has and dynamic data is the custom data input by the user in the app.
This would enable you to have your admin panel, as well as RESTful APIs, served in different languages.
Here’s a fun experiment: Mention timezones within earshot of any experienced programmer. Now wait until the profanity stops.
Handling dates and time is an incredibly common requirement in computer applications. That’s hardly surprising - we all use computers to record when we did old things, track how long things take, and to plan when we’re going to do things. So why is dealing with time so difficult?
Well, it’s because time has a very sordid history. What we even think of as time has changed. In this talk, you’ll travel through time, and see the impact that two thousand years of history have had on our modern life. You’ll be shown how all this wibbly-wobbly, timey-wimey history stuff affects the data modelling and APIs we use on a daily basis.
This is going to take some… time.
00:00 - Matt Shapman
05:52 - Ryan Sullivan
10:35 - Kyle Gibson
15:48 - Philip James
19:11 - Caz Downing-Bryant
24:06 - Andrew Pinkham
27:57 - Mariatta Wijaya
Django looks like it’s doing just fine: it’s a popular framework in a popular language. We have major releases every six months. We have Django Girls, a Foundation (and Fellows), super conferences in glamorous locations, and more.
But the code is old, there are 1300+ accepted open issues. There’s only the smallest number of people that regularly contribute code.
It’s fine now. But it won’t be. Your web framework needs you!
Contributing to open source is great, and it’s great for you. Historically we’ve not been that good at encouraging new and diverse contributors. We’re trying to change that, and we want to invite you to come and join-in.
I’m going to tell you quickly how to get involved, how to get support in that, and how to let us know if that’s failing.
You are qualified to contribute. More than that, your contribution is the future of Django. Come code.
Anna’s keynote will dive into her journey with coding, what got her interested in programming and why she chose Python despite the language not being popular in her region. She will also talk about her journey learning to code in Python and how her involvement in the Python community as a beginner has helped her grow and develop her coding skills. She will share what mentorship means to her and how positive mentorship can impact the lives of many beginner coders.
Traditional Django handles user authentication for us. REST Framework? Not so much. The abundance of choice is overwhelming and typically THE biggest obstacle for newcomers.
This talk is a deep dive on authentication in Django REST Framework. We’ll start with an overview of HTTP and REST APIs before demonstrating how to implement the 4 built-in auth modes and their respective pros/cons. Special attention will be paid to common gotchas such as, Why do I need “both” TokenAuth and SessionAuth? What are JWTs?
Next we’ll implement a real-world REST auth setup that includes user registration, password reset/confirm, social auth, and endpoints for sign up, log in, and log out. The third-party packages django-rest-auth and django-allauth will be used .
By the end of the talk attendees will understand the basics of REST authentication, the tradeoffs involved, and walk away with a working implementation to jumpstart their future projects.
Drawing upon decades of simulation and higher education experience, the Alfred West Jr. Learning Lab at the Wharton School set out to create it’s own in-house developed simulation platform to accelerate our simulation delivery capabilities. However, what began as a white boarding session two years ago, morphed into the first of its kind open source simulation platform. Simpl will not only fuel the next generation of simulations written at the Wharton School, but it is our hope it will serve the foundation for countless other simulations at other schools around the world. Our open source platform puts tools in the hands of any developer who has the curiosity to create a simulation, tools that were previously unobtainable due to cost. The Learning Lab partnered with RevSys, and relying upon Python/Django and a slew of other open source tools, we were able to deliver our first simulation written in Simpl in November of 2017.
In this talk you will learn about simulations in the higher education space, how we developed and implemented Simpl, a demo of our first Simpl simulation, and why we think this Python/Django fueled simulation platform will have a seismic impact on the burgeoning edtech field.
Tentative outline of talk:
About the Learning Lab and simulations
The barrier to develop simulations
Why we chose to develop Simpl and make it open source
Simpl design process
Experience writing first Simpl simulation
Technical deep dive
Demo of first Simpl sim
Where we are, next steps
Machine Learning is probably the most important development in our industry (and possibly our civilisation!). Previously restricted to math geniuses with access to supercomputers and massive data centres, machine learning tools are increasingly available as web services which are easily consumed from more traditional web applications. Python has become the lingua franca of machine learning, so Django developers are well placed to take advantage of the next wave of application development.
In this talk I’ll outline the various machine learning platforms and provide a set of practical examples that demonstrate how Django developers can start taking advantage of artificial intelligence in their own applications. These will include:
Image recognition - using Microsoft Azure Vision to automatically caption and label the images your users upload
Entity analysis - using the Google Cloud Natural Language API to tag news articles with people, locations and events
Predictions - using Amazon Machine Learning to build a ‘you may also like’ feature
Sentiment analysis - using IBM Watson to understand the tone of comments submitted to your site
GraphQL has grown a lot overtime, but it seems to still be a new “thing” in the Python and Django World. This talk will be an introduction to GraphQL, explaining why it has been created and how you can use it in Python and Django.
Short speaker introduction
Small digression on how the “old” web used to be and how it has now evolved into the modern web
Really quick explanation of REST (just to make sure everyone is familiar with it)
What are some limitations of REST? What can we do about it?
Introduction to GraphQL, what it is, how’s using it and when has it been created?
GraphQL: query language syntax
GraphQL: types and introspection
GraphQL: operation, how to read data,update data and more
How to use Graphql with Python and Django
Let’s make a simple API
How to create queries
How to create mutations
Things to consider (security caching and performance)
Somewhere between 5% and 12% of adults have ADHD. Even if you do not have the disorder yourself you probably work, live or know someone who does. But the world is not designed for people with ADHD, so to be successful I’ve had to develop techniques to keep my concentration and procrastination in check.
In this talk, we’ll briefly look at what ADHD is and how it impairs not only concentration but also executive function. Then we’ll explore how changes in the workplace can benefit not just those with ADHD, but anyone whose work requires creativity or extended periods of focus. Next, we’ll look at some persistent myths about productivity, and what you can do personally to increase your concentration and output without burning out. Then I’ll present some techniques you can rollout within your team to remove distractions while improving the quality of communication.
Basics of the language (types, operators, data structures, functions, modules, etc. as seen in ES6) and how they are similar to or different from Python.
Overview of the commonly used development and build tools.
Overview of the popular frontend frameworks.
A look into the newest features of ES6 and Typescript.
How to get started and make sense of everything with so much going on.
A common set of considerations when planning to release a new application are around hosting and resources:
Which platforms will support my app?
What OS should I use?
What WSGI server should I use?
How much memory and CPU do I need?
Zappa, a framework for running serverless WSGI applications on top of AWS Lambda, can help address these and other questions around application deployment. With some configuration (as code), Zappa can get you up and running quickly, letting you focus on developing the application instead of the infrastructure.
In this talk we’ll go through some of these kinds of questions to see how they might be answered in traditional solutions and then see how Zappa handles them. We’ll also talk about a few specific configuration options for handling SSL certificates and running Django commands on the Zappa-deployed application.
The fact that tech is struggling to hire or retain employees from diverse backgrounds has been written about and discussed thoroughly, particularly in the last few years. The economic, societal, and moral benefits of diversity are also well documented. Why is it hard, then, for well-intentioned organizations to shift their demographics? There are a number of reasons, but one that doesn’t appear to have been thoroughly discussed already is the challenge of gathering and responding to data about diversity within a company’s hiring pool and existing employees. One hack day, I was involved in too many projects and had only a token amount of time to devote to the one I was most interested in; seeing if we could determine whether we had sufficient diversity for any given role to start interviewing candidates, or if we needed to spend more efforts sourcing diverse candidates for the pool. I accomplished an MVP in approximately an hour, once I had an api key and permissions. It doesn’t necessarily require a huge effort to make a big difference.
In this talk, I’ll walk through the MVP indicating, for each role, whether there was “sufficient diversity”. I’ll also address gotchas, limitations, and What Now.
Many Django developers are familiar with building APIs, but what about when you need to build a mobile client consume them? Wouldn’t it be great if you could build a mobile application using the same language as your backend?
Well, you can!
This talk will introduce Kivy, a framework for building multi-touch applications. We’ll cover all the basics, including…
Why you’d want to build mobile apps in Python, and what other options exist
How to install Kivy (It’s really easy!)
Basic examples of what a Kivy app looks like
The Kv Design language, a YAML-esque abstraction for rapidly building UI’s
How to access the hardware features of your device
How to package your app for the Google Play and iOS App stores
We’ll provide everything you need to know to get started building Python-powered phone apps with Kivy.
A hot topic in recent years is running applications in containers. Tools such as docker and rkt have made deployment of applications using Linux containers easier, but they do not alone provide everything that is needed to easily manage many applications, or run containers at scale across a cluster of machines.
In this talk you will learn about the fundamental concepts and terminology of Kubernetes and why it is emerging as the de-facto standard for container orchestration and scheduling.
The talk will step through how to deploy to Kubernetes a Python web application, implemented using Django, as a way of seeing what happens under the covers when you do so.
Your apartment building where you wake up. The water you drink. The car you drive. The road on which you drive.
In the first hour of your day, you rely on the work of several distinct branches of engineering, whose practitioners are licensed and accountable to the public.
In the second hour of your day, you may sit down at your desk to write code that dozens, hundreds, thousands, millions of people interact with in some way–but what do they know about you, your intentions, and your training?
A licensed Civil Engineer turned software developer will talk through how her former field approached ethics–something they have been iterating on for more than 3000 years. She will discuss how lessons learned from other engineering professions could apply to software, and where our industry may need a new approach to ethics.
There’s a good practice that says “a database is a representer of facts”. If there’s more than one way to extract a single fact from the database, then there’s a redundancy in it. Every redundancy can cause different anomalies in the data, which in turn cause bugs in the application. To avoid that, there’s a process called normalization, which involves following sets of rules to restructure the database to remove redundancies without losing the original facts. The traditional set of normalization rules are the so-called Normal Forms: First Normal Form, Second, Third, etc. Unfortunately, those are frequently overlooked by developers due to their excessive formalism. But in fact, even the Normal Forms aren’t enough to avoid anomalies, since they’re concerned about redundancies only in a single table*. Since cross-table dependencies are very common in modern applications, we must go beyond normal forms to prevent problems.
In this talk, we’ll present normalization rules on a friendly language, going beyond normal forms. We’ll understand how the software requirements cause dependencies in database tables, both in-table and cross-tables. We’ll show real examples of non-trivial dependencies that happen on Django models. We’ll discuss how normalization prevents redundancies, inconsistencies, anomalies, and bugs. Knowing that normalization can cause slowdowns in queries, we’ll present how to increase performance with denormalization, which is not the same of not normalizing. Instead, denormalization means being able to represent data in multiple ways to speed up queries without introducing inconsistencies. We’ll discuss Django-related denormalization tools that use cronjobs, indexes, caching, materialized views and triggers, and NoSQL.
*It’s common to ignore the fact that normal forms only discuss redundancies inside a single table/record/relval. More about this in this article reviewed by Codd, Fagin and Date, key figures of the relational model.
So, you built a Django application. That’s great! Now, how do you get the app connected to your fancy domain name for the world to see? During this talk, you’ll learn about the phone book of the internet, otherwise known as the Domain Name Systems (DNS). We’ll go over topics such as: why DNS was created, how it works, and why it’s important for developers have a good understanding of DNS.
As a web developer who has launched hundreds of websites, I’ll tell you stories of some of my own DNS disasters and odd quirks that I’ve ran into over the last 5 years. If you’ve ever wondered why you can see your newly launched website but your coworker can’t, or if you’re ready to launch your first client website, but not take down their email in the process, you won’t want to miss this talk.
Are you having trouble getting beginners to stick around in your user group? What’s the best way to help people who are just getting started with Django and Python? Are you finding it difficult to attract and keep a diverse audience? Since I started PyLadies Boston in 2013, I’ve learned a few lessons about the best way to help out beginners and cultivate a welcoming community for marginalized folks. In this talk, I will cover:
Starting a group with the intention to be beginner-friendly
Creating a welcoming environment
Beginner friendly meeting topics
Finding the best way to teach people to code
Being a good ally
This talk will benefit anyone who is currently running or thinking of starting a user group.
Managing a large open source project like CPython is no easy task. Learn how the Python core team automated their GitHub workflow with bots, making it easier for maintainers and contributors to collaborate together. Even if you’re not managing a large project, you can still build your own bot! Hear some ideas on what you can automate on GitHub and personalize your bot based on your own workflow. All you need is Python. Don’t be a robot; build the bot.
So you’ve made your first attempt at creating a DRF API, but now you need to figure out how to put the hair on the proverbial pony. You want to make things easier on your client developers so they can get exactly what they need. I’ll walk through things that made our lives better developing a Django REST Framework API serving a React frontend.
I’ll include optimizations such as embedding related fields into serializers, using different serializers for different users and use cases (HTTP methods), and using DRF’s actions decorator to provide easy access to related tasks. I’ll also touch on some third-party libraries that made life way easier, such as rest-framework-filters, django-rest-swagger, and django-simple-history.
What does it take to build a web application that can serve millions of concurrent users? This talk will dissect Open edX, the open source online learning platform that powers edX.org and hundreds of other sites around the world.
Open edX is written in Django but relies on a slew of other software to work at scale. We’ll break down the components of the entire software architecture, and explain how each component is used. This will give attendees some insights into how they might architect their web application if they’re building software to serve a large audience.
We’ll discuss how Open edX utilizes both MySQL and MongoDB as data stores and why it uses MySQL for student data and MongoDB for course data. We’ll describe the queing architecture of Celery and RabbitMQ to process background jobs, and Hadoop for processing terabytes of learner analytics data.
DevOps enthusiasts will not be disappointed as we’ll go into the use of Ansible and Terraform for deploying the entire suite of software in a consistent and repeatable way up to popular cloud providers such as AWS, Google Cloud and Azure.
What will attendees learn? The attendees will get a close look at a modern Django-based web application to see how it’s architected, and come away with a better understanding of design decisions when building a web application that needs to serve 35M users from every country in the world. Attendees will also be equipped with the knowledge to run Open edX on their laptop or in the cloud, if they want to explore the software further.
This talk will cover what GDPR is and why you should care about it, but we won’t stop there. This is not going to be another talk on data protection policy. No.
In this talk, we’re going to jump right into discussing HOW to implement data patterns that comply with regulations like GDPR by examining a pattern known as pseudonymization.
Pseudonymization is a data de-identification procedure where fields of personally identifiable information (PII) within a data record are replaced by one or more artificial identifiers. These artificial identifiers are also called pseudonyms. Pseudonyms make a data record less identifiable without sacrificing data analysis and processing. GDPR requires that PII undergo either pseudonymization or complete data anonymization.
For the hands-on portion of this talk, we’ll construct a Django User Model where we apply pseudonyms to the data attributes which qualify as PII. We’ll explore a couple strategies for implementing a compliant pseudonymization pattern, examining their individual approaches and performance, and we’ll discuss limitations of pseudonymizing certain attributes and how to achieve compliance through consent.
GDPR sets a precedent for responsible data management. Whether your application serves citizens of the EU or not, the regulations serve as an encouragement for protecting your user’s identities. This talk is great for everyone from beginners to expert Django developers… and fans of Phil Collins :)
When bundling up data, sometimes tuples and dictionaries don’t quite cut it. Python’s classes are powerful tools for data storage and manipulation, but it can take quite a bit of boilerplate code to make a well-behaved Python class. In this talk we’re going to discuss how a well-behaved class should work and take a look at a number of helper libraries for creating well-behaved classes.
We’ll first see how to make classes with proper string representations, comparability, iterability, and immutability. Then we’ll dive into helper tools built-in to the standard library and available in third-party libraries and briefly discuss which of these tools makes sense to use with Django’s classes.
We’ll look at namedtuple, NamedTuple (not a typo), attrs, and the new Python 3.7 dataclasses.
Most of the libraries discussed in this talk are only available in Python 3, so if you’re not using Python 3, hopefully this talk will encourage you to upgrade.
00:00 - Rachell Calhoun
03:48 - Vince Salvino
08:52 - Sergey Golovchenko
14:06 - Dan Taylor
19:20 - Noah Kantrowitz
23:56 - Tyler Jackson
28:26 - Laura Lorenz
33:11 - Elad Silberring
37:36 - Luan Fonsecca
Python covers a significant portion of the present day Web services landscape because of frameworks like Django, Flask, CherryPy etc. Many Highly Scalable services are built on one or more of these frameworks.
However, there is a perception among developers that these frameworks protected all classes of Web attacks and the OWASP Top 10 vulnerabilities. This is because of the inherent middleware that has battle-tested controls against some common vulnerabilities like CSRF, SQL Injection, and XSS. However, I have observed that many Python devs do not watch out for lesser-known vulnerabilities that seem to be rife in many Python Web Apps. For instance, in more recent security tests against Python Web Services that our team executes, I find that vulnerabilities like Insecure Deserialization, XML External Entities, Server-Side Template Injection and Authorization Flaws are quite prevalent.
As a developer (largely of Python Web Apps), I find that there are some simple steps that engineering teams can take towards finding and fixing such vulnerabilities with Python Web Services built on Django and Flask. My talk is meant to be a holistic perspective on finding and fixing some uncommon flaws in Python Web Apps. The talk will be replete with multiple demos, anecdotes, and examples of secure and insecure code in Python. I will also delve into SAST and DAST techniques (AST and ZAP Custom Scripts) to identify such flaws in python web applications.
The example repository will be available on GitHub for the community to use.
Deployments can be stressful, but should’nt be. We all hear about big companies deploying several, if not thousands of times a day. In order to acheive this, you have to be able to deploy without impacting performance at all; you need to feel confident and comfortable when you deploy. Even a couple miliseconds of downtime is unacceptable in these environments. Whether you have to provide SLA’s to your customers or not, being able to deploy without any downtime, allows you to deploy more often, which leads to faster turnaround time on both bug fixes and features. Successfully deploying without and downtime, however, is non-trivial. Perhaps you have heard the term Blue/Green deployment, and wonder what that is. Come learn about some of the strategies used for deployments, as well as all the changes to your code and your process you will have to make in order for it to truly work, and make you feel more confident on every deploy to production.
This talk will give you some tips and techniques as well as some real (raw) examples of how I was able to start a company at 23 years old, lock in an investment, and beat out my competitors who were a lot older and more experienced than I. The talk will demonstrate different scenarios and solutions in which it takes to stand out, and be remembered in a saturated market, in whatever field you may be in. Whether you are a developer interviewing for your dream job, starting a business, or somewhere in between and just trying to make your way in the world. Implementing emotional awareness and intelligence in your life will change not just the way you interview but the way you are perceived by others in your work life, as well as your social life.
My friends call it the “Amber effect” but I call it, giving a damn.
In this talk we will cover:
How to leave a lasting impression, every time.
The importance of long term benefits vs instant gratification when it comes to building relationships
How to stand out as a potential job applicant
How to get the attention of a prospective client, including c-level executives.
How to identify opportunity and advantages out of unexpected circumstances (When things don’t go your way)
How to add value beyond scope of work
Genuinely giving a damn without expectation
Django tutorials often use the perspective of a complete newcomer to Python and web development, and while they provide a good practical on-ramp for brand new developers, they are often not quite right for developers from other backgrounds.
The common backbone of MVC development, no matter the base language, is the database and the language specifically for it’s manipulation: Structured Query Language (SQL). But Django hides this behind it’s amazing drawcard, the Object Relational Model (ORM).
But how can a developer already familiar with SQL get a handle on the ORM?
This talk endeavours to introduce the ORM using shared SQL and relational database concepts, showcasing the features the ORM uses to make database querying and manipulation a joy, rather than a burden, to the polyglot developer.
There is a multitude of options to translate database data in Django, for example django-parler, django-modeltranslation, django-nece, django-hvad, and django-i18nfield (which is my own). The interesting thing is that these libraries are not multiple implementations of the same thing, but they are all radically different in their design and there are good reasons for every one of them. The sometimes subtle differences might not be obvious to a beginner in the Django world. This talk will help them navigate through different solutions and make an informed decision.
Join us for a panel on the State of Django: the state of the Django codebase, but also the state of the Django community as represented by organizations like the Django Software Foundation, Django Girls, and DEFNA.
Moderated by Simon Willison, our panelists will discuss:
how we can continue to grow the Django community and create a welcoming space for beginners
the priorities for the continued development and maturation of Django
ways to improve Django events and bring them to new regions worldwide
success stories from Django communities
concrete steps toward better and more effective diversity and inclusion efforts
and much more. It’s been a long time since we gathered leaders of the Django community on one stage to have an open-ended discussion about Django’s present and future, and we hope you’ll join us for this special event.
Josue Balandrano Coronel
This talk will detail my experience building an Augmentative Alternative Communication (AAC) device for my son who has autism. I had to perform some troubleshooting to get Django to harmonize with the Raspbian OS and touchscreen drivers, but the result is easily replicable using the instructions I will cover from my project documentation on the Hackaday website bit.ly/TalkerHackaday
I want to give this talk to inspire other developers to try their hand at building bespoke assistive devices. Commercially available medical assistive devices are expensive partly because they try to be everything to everybody. What if instead, we made products that do one thing for one specific user very well?
This outline shows what I will cover in my talk:
Find a need and fill it
Django on Linux
Gesture recognition for touchscreen
Custom enclosures with NO 3D printing
Everyone needs to become an inventor
This talk is for people who are curious about running Django in an embedded system (development server as the production environment). People who are interested in Debian Linux will also find this talk interesting. I would love to reach the autism community and people who want to build assistive technology. To get the most out of this talk, attendees should have a basic knowledge of how to perform a command line Django installation and what a raspberry pi is.
GeoDjango is Django’s robust geographic Web framework to build GIS applications and handle geospatial data. It relies on PostGIS (PostgreSQL’s database for geospatial objects) and the Python library GDAL. This talk will discuss how GeoDjango uses these to extend Django models to handle complex geometries and geographic queries. This talk is intended for software developers and those interested in mapping location data. There will be a short demonstration on how GeoDjango works with popular mapping frameworks like Leaflet and OpenStreetMaps. We will create a GeoDjango model, seed our PostGIS database using raw location data, and make a simple route and view so we can actually visualize some data on a Leaflet map. We will also discuss the difference between raster and vector data, geos geometries and geojson, and spatial reference systems.
In the past it was simpler and easier to think of building websites exclusively for desktop monitors capable of showing 1024x768 pixels, sitting on the desk of a non-impaired, English-speaking person. But today we need to embrace a much broader range of users. And one part of this is designing sites for the visually impaired.
There are automatic checkers that you can use to assess your site’s accessibility. It will tell you that all your images need an alt tag, and that the H2 should come after the H1. This is a good start, but even if you dot all your i’s and cross all your t’s and get 100% pass, your site may be an unnavigable mess in practice.
In this talk we will look at and listen to real world examples of websites that either pass or fail the accessibility test. We will hear anecdotes from actual visually impaired users and discover how they navigate the web. And we will see that even though frameworks like Django can set us up for success, it’s up to us as developers to follow through.