1. First, we load the specific Wagtail page instance we want to modify;
2. Then, we load a Python structure (a list of dictionaries) representing the StreamField contents;
3. Next, we modify the structure to add, change, or remove the StreamField elements programmatically;
4. Finally, we save the changes as a new revision.

Let’s assume we have the following Page model made up of a StreamField:

# my_app/models.py
from wagtail.core.blocks import RichTextBlock, TextBlock
from wagtail.core.fields import StreamField
from wagtail.core.models import Page
from wagtail.documents.blocks import DocumentChooserBlock, StreamBlock
from wagtail.embeds.blocks import EmbedBlock


class ContentStreamBlock(StreamBlock):
    heading = TextBlock()
    paragraph = RichTextField(features=['h2', 'h3', 'bold', 'italic', 'link'])
    document = DocumentChooserBlock()
    embed = EmbedBlock()


class MyPage(Page):
    body = StreamField(ContentStreamBlock())

    content_panels = Page.content_panels + [StreamFieldPanel('body')]

Here’s an example of how we could loop through the instances of MyPage, programmatically removing any embed we encounter.

from json import dumps

from django.utils import timezone

from wagtail.core.fields import StreamField

from my_app.models import ContentStreamBlock, MyPage


for my_page in MyPage.objects.all():
    # Create a blank list for the revised StreamField
    new_streamfield_struct = []

    # Grab the existing StreamField as a list of dicts
    streamfield_struct = my_page.specific.body.get_prep_value()

    # Loop through the StreamField elements, drop any embeds
    for index, element in enumerate(streamfield_struct):
        if element["type"] != "embed":
            new_streamfield_struct.append(element)

    # Convert the new_streamfield_struct back to a StreamField and save a new revision
    my_page.body = StreamField(
        ContentStreamBlock()).to_python(dumps(new_streamfield_struct)
    )
    revision = my_page.save_revision(submitted_for_moderation=False)
    revision.publish()
    my_page.live_revision = revision
    my_page.live_revision_id = revision.id
    my_page.last_revision_created_at = timezone.now()
    my_page.save()
    print(f"Saved new page with page_id {my_page.id}.")

That’s the formula! You can do whatever you like in the part of the code where I’ve dropped embed elements as an example, just make sure to carefully verify and validate your StreamField structure. It is worth examining your structure in detail so you understand how it is stored as JSON in the database, and how to manipulate it as a Python structure.

So what is the metaverse? A clinical answer to the question might be, “a persistent, three-dimensional virtual space in which people can interact via avatars in a plethora of interesting ways.” The idealist in me would insist that the metaverse should be, “the ultimate blank canvas for our dreams, a place where people can explore new levels of intellectual curiosity, whimsy, and hopefully, mutual understanding on a level playing field.”

The Origin of the Term Metaverse

I first read the term “metaverse” as a senior in high school. I had been programming computers since I was about six years old, so by this time, I had been tinkering with code and hardware for over a decade. I was beginning to dream of a future where the internet would be part of our daily lives. In his 2006 book, Techno-Cultural Evolution: Cycles of Creation and Conflict, William McDonald Wallace argues that human evolution has had three major spikes after crucial inventions have come to be:

• the first, after we became an agricultural society, rather than one that hunted and gathered;
• the second, after the invention of the printing press;
• and now, the third, where we have flattened communication across the planet with the internet.

It is a compelling thought and could explain the growing pains humanity has been experiencing the past two decades. Humans aren’t huge fans of change, and the internet and globalization have changed everything. The rate of accelerated change is affecting even the most ardent techies among us, and it is something humanity will continue to wrestle with for generations to come.

Before I was a teenager, I loved playing with computers because it was the next logical step beyond Lego, but by high school, I had begun to understand that everything was about to change: EVERYTHING. I had started using my modem to network with people around Philadelphia, and discovered multi-node BBS’s, where we could chat and play games together in virtual spaces, including a game called Infinity Complex, which sucked down many hours of my friends and my time. I graduated from high school in June 1992, the same month that Neal Stephenson released his seminal cyberpunk novel, Snow Crash. This was the book in which he coined the term “metaverse”, to describe a persistent three-dimension space experienced as a city, called “the Street.”

More of My Background

I read Snow Crash over the summer of 1992, and it fueled my dreams, inspiring me to create an individualized major at the University of Pennsylvania. We were making our own worlds on the internet, including PennMOO, and all-text-based chat world on campus. I graduated in 1996 with a degree combining Computer Science, Psychology, Cognitive Science, and Philosophy. Throughout college, I was an early adopter of anything and everything to do with virtual reality. I was one of the early adopters of ActiveWorlds (you can search for FlipperPA on their early citizen list!), Worlds.NET, Virtual Places, and many others. I spent countless hours online. I am friends to this day with some of the wonderful people I met through these virtual worlds; the bonds created are real, and the friendships have lasted for decades.

I wrote my senior thesis on using computers alongside the human mind for better understanding, which now sounds obvious, but was novel at the time. By the end of college, I was dreaming of this elusive “metaverse” coming to fruition. I wanted it to be a better way forward for humanity.

My Obsessions and Addictions

I should mention that I’m an addict. I can get obsessive about things. I have always been full-on into technology my entire life, but by the end of college, I was also an alcoholic. With the demand for technology professionals never ceasing, the two tended to go hand-in-hand. Idiotic catchphrases like “work hard, play hard” gave me the excuse I wanted to continue to allow my behavior to slide. I’m now recovered, but for much of what you’re about to read, I was a functional active alcoholic.

The Second Life Years

I wasn’t the only person inspired by this novel: Philip Rosedale cites it as his primary inspiration for founding Linden Lab. Linden Lab was the company that created the virtual world Second Life - who were largely the subject of the last wave of hype about virtual worlds, circa 2005 through 2008. I joined Second Life almost exactly 18 years ago at the time of this writing: November 14th, 2003. The Chief Technology Officer of Linden Lab, Cory Ondrejka, would go on to become Vice President of Engineering for Facebook, and is largely responsible for convincing Mark Zuckerberg to purchase Oculus. Cory Ondrejka had taken the bold step of announcing that any creation in Second Life would remain the intellectual property of the creator. I saw the article on Slashdot and created my account minutes later. A week later, I bought a new laptop with a powerful graphics card, and it was off to the races.

It wasn’t long before I was the first person to buy an entire mainland simulator - a virtual section of land, 256 meters by 256 meters, or about 16 acres. It was called Indigo, and I assembled a crew of friends to help build it out. This is where I first experienced the feeling of building my dreams on a blank canvas. It was amazing, and I was immersed. It wasn’t long before I became friends with many of the employees and upper management of Linden Lab, including Philip, Cory, and Robin Harper, the VP of Community Development. They were amazing minds in an amazing startup during a wonderful time.

Second Life got a lot of coverage because of avatars having sex. This always seemed a bit absurd to me. Humans are sexual creatures. Most new technologies are first used, and pushed to their limits, by sex-related industries. People viewing pornography seems to be largely accepted by society. Yet, a virtual world sexual encounter, where there is an actual person on the other end and not a recording, is weird for some reason? That never quite made sense to me. I had a friend in Second Life, charming and hilarious, who was wheelchair-bound. He met his wife through Second Life and told me he would never have had the confidence to meet a woman without it.

Second Life also made things like Brigadoon possible. Brigadoon was a private area of Second Life, where children with Asperger’s Syndrome could congregate. They could learn social skills by communicating with one another, all from the comfort of their own homes. This was amazingly effective, and an unexpected byproduct of this was, it became an incredible support network for the parents. The Second Life community raised hundreds of thousands of dollars for the American Cancer Society’s Relay for Life in incredibly creative ways. This is just the tip of the iceberg of uplifting stories from the Second Life community.

With a few friends and my former wife, I was a founding member of The Second Life Community Convention, which I organized from 2005 through 2007. 2005’s convention in New York was 150 people; nine months later in San Francisco, we had a second in 2006, with 500 people. In 2007, with the hype cycle in full force, we had over 1,000 people show up in Chicago for SLCC 2007.

During this time, I also started a company on a dare by accident, entirely virtually. It was called SLBoutique, and it was a website where anyone who created content in the virtual world could sell it through a common web portal. Items were delivered in real-time in the virtual world via XML-RPC calls to objects in the virtual world from the web, and payments were made in real time to the sellers. I decided to take it a step further and began selling real-world items - such as computer monitors and video cards - for Second Life’s currency, the Linden dollar. This got me coverage in BusinessWeek, MTV, The Guardian, and many other outlets. My former wife and I were featured on MSNBC, CNBC, CNN, and ABC… all over the place. It was a crazy time.

In the era of BitCoin, it is crazy to think that I was the first person to sell real-world items for a virtual currency, and I did it on a drunken dare!

So What Now?

I consider Cory Ondrejka a friend, but I am saddened that Facebook has gotten involved in virtual worlds and have trouble reconciling that the person who ensured that Second Life residents retained their intellectual property would start the ball rolling for one of the worst companies in the world to dominate virtual reality. I can think of very few people who will be a worse steward of the potential of the metaverse than Mark Zuckerberg.

We have finally reached a point where technology is catching up with our dreams, through products like the Valve Index, HTC Vive, and Oculus, and I’m watching Facebook do what they always do: buy out any potential competitor. They’ve bought Oculus, and released a $300 model which is dominating the marketplace. They are requiring a Facebook account to use it. They have purchased the development company that makes one of my favorite games, Beat Saber.

I wake up every morning and do a 45-minute workout with my virtual reality headset on, and people don’t seem to think it is that weird anymore. I’ve got friends I’ve made through virtual worlds for over 25 years. Just because Mark Zuckerberg puts out a press release doesn’t change what we can do, and I hope we choose more wisely than we have with Facebook. I believe the data show that Trump never becomes President without Facebook, and that 650,000 Americans likely would be alive without Trump putting himself before the country during this pandemic. And yet, Zuckerberg continues to put his algorithm and profits above human life. It is despicable.

The metaverse is theoretical; the metaverse is NOT Facebook’s Meta. The metaverse is a vast potential that no one owns. We can still make the metaverse the place of OUR dreams.

I’ve been a virtual reality enthusiast for many years, since it became a buzzword during the early 1990s. I saw Lawnmower Man in the theater, and was a part of early virtual communities such as ActiveWorlds. I had fifteen minutes of internet fame when I became the first person to successfully sell real world items (video cards and monitors) for a game currency.

Second Life was such an amazing place to be when it started; it was the ultimate blank canvas for dreamers. You could build and collaborate in real time, and there was this sense that we were all pieces of this shared artwork that was constantly in motion. Back in 2003, most of the regulars knew each other, like a small town, with the friendships and rivalries that came with it.

After many enjoyable years being heavily involved in Second Life, I took some time away. I got very involved in the Python and Django communities, got sober, and rediscovered my love for all things coding. When the latest wave of virtual reality headsets started to appear, such as the original Oculus and HTC Vive, I was a bit skeptical. But the technology had finally start to catch up to the dream of immersion. After my friend Saron Itbarek had me over with some friends during a visit to San Diego, the assembled party tried out her HTC Vive, many being immersed for the first time. After some sage-like advice from her partner Robert, I got my own HTC Vive, and a few months later, I found I was using it enough to warrant purchasing a Valve Index.

I was never taken by rhythm games like Dance Dance Revolution or Guitar Hero in the past, but Beat Saber has not only become what I spend most of my virtual reality time doing, it is my exercise routine. It has me in the best shape of my life. I do about thirty minutes of intense mixed cardio every morning.

Recently, Beat Saber introduced an online head-to-head mode, where up to five players can play head-to-head with the same song. It may be by complete accident, but it seems like they may have made the friendliest online community I have ever been a part of:

• All players can create avatars and have a name.
• Players can gesture with their hands, and you can see their heads move as well.
• There is no voice interaction.
• There is no chat window.

This has led to a rich language of gestures evolving: players enthusiastically wave hello when a new player joins the game. It is common to see people clapping to the person who won the round, and the winner graciously taking a “namaste” bow. People wave goodbye, and gesture up to the center board in between songs to encourage a newcomer to select the song they would like to play next.

It is incredibly friendly and warm. Has Beat Saber accidentally stumbled on a wonderful way for us to communicate in games? There’s zero moderation necessary, and a language has started to evolve which brings no stress or drama, only positive emotions. It has been heartening to see.

• Two bread pans, about 9” x 5” and cooling trays
• 1.5 ounces of active dry yeast
• 16 ounces extra sharp cheddar cheese (I prefer orange to give the bread color!)
• Seven to nine cups of all-purpose flour
• Slightly less than a half teaspoon of salt
• Less than a tablespoon of sugar
• 3 tablespoons of vegetable oil

• Add packets of yeast to half a cup of “warm to the touch” water
• Sprinkle enough sugar on top of the yeast to cover it and start it bubbling - between a teaspoon and a tablespoon of sugar
• Grate the 16 ounces of cheese while sugar bubbles in with yeast
• Put cheese in a mixing bowl and add less than half a teaspoon of salt
• Wait for water/yeast/sugar mix to look mushy; by the time you’ve finished shredding the cheese, it should be mostly ready.
• Add 2 cups of hot water (very hot but not boiling - like a hot shower)
• Give a quick stir, add yeast mix, and re-stir
• Add six cups of flour, two cups at a time.
  • Stir it together
  • Before dumping to the counter, prepare a measuring cup with three to four cups of flour. You won’t use it all, but need easy access as your hands are about to get really messy!
  • After six cups, dump the entire mix to the counter from the bowl.
• Continue to add flour by feel, up to about nine cups in winter, or seven in summer.
• Fine tune the mix together after six cups. It tastes cheesier the less flour you use.
• After it’s all mixed into a nice ball the size of a volleyball, add it back to the mixing bowl.
• Add one to two teaspoons of vegetable oil on one side of the ball - spread it around, and use enough to cover it. Turn the ball over and do the same to the other side.
• Fold a hand towel in half and put it over the mixing bowl. Let it rise for about 30 minutes, until the ball is pushing up on the towel.
• Take the risen ball out of the bowl, re-knead it to get all the air bubbles out (or you’ll have holey bread!)
• Spray the bread pans with Pam, especially the corners.
• Split the ball into two and put it in the pans, cover the pans to let it rise again.
• Pre-heat oven to 350, and let the mix rise to top of pans (about 20 to 30 minutes)
• Put in the lower half of the oven for 30 to 40 minutes
• Using two pot holders, check the bottom of the loaf to make sure it isn’t moist; when it is dry, the bread is done!
• Let it cool on a cooling tray, or eat it fresh out of the oven!

Let’s face it: managing users is likely the most important core aspect of any web project. It isn’t easy, and one size does not fit all. It might be tempting to overlook this architecture, or kick the can down the road, but it is one element where I have seen many projects pay the price for not planning up front.

Just over the past few weeks, I’ve had conversations with several friends who considered using Django’s out-of-the-box django.contrib.auth User model. This should be avoided, and it even says so in Django’s documentation. So how do you do it right? While there is no singular perfect solution, there is a flexible way of getting started, which I will outline here.

I’m a big fan of the django-allauth package, and recommend using it in conjunction with a custom Django users model. If you want a fuller understanding of Django custom user model options, please see this excellent article.

Our Example users App

For this example, let’s assume we are doing the more complex task outlined in the article above.

• We create an app called users with a model called User
• User subclasses AbstractBaseUser, using the email field as the username
• Users may login with a local email and password combination, or by using Facebook, Twitter, or Google’s third party authorization options.

Here’s an example of how our users/models.py might look like.

from django.contrib.auth.models import (
    BaseUserManager, AbstractBaseUser, PermissionsMixin
)
from django.db import models


class UserManager(BaseUserManager):
    def create_user(self, email, password=None):
        if not email:
            raise ValueError("Users must have an email address.")

        user = self.model(email=self.normalize_email(email))
        user.set_password(password)
        user.save(using=self._db)

        return user

    def create_superuser(self, email, password):
        user = self.create_user(email,password=password)
        user.is_superuser = True
        user.is_staff = True
        user.save(using=self._db)

        return user


class User(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(
        verbose_name='email address',
        unique=True,
        db_index=True,
    )
    full_name = models.CharField(
        max_length=191,
        blank=True,
    )
    short_name = models.CharField(
        max_length=191,
        blank=True,
    )
    is_active = models.BooleanField(default=True)
    is_staff = models.BooleanField(default=False)

    objects = UserManager()

    USERNAME_FIELD = "email"

    def get_full_name(self):
        return self.full_name

    def get_short_name(self):
        return self.short_name

    def __str__(self):
        return f"{self.email} ({self.full_name})"

Modifying Our Settings

First, we need to wire up django-allauth to our Django project.

AUTH_APPS = [
    "django.contrib.sites",
    "allauth",
    "allauth.account",
    "allauth.socialaccount",
    "allauth.socialaccount.providers.facebook",
    "allauth.socialaccount.providers.google",
    "allauth.socialaccount.providers.twitter",
]

SITE_ID = 1

INSTALLED_APPS += AUTH_APPS

AUTH_USER_MODEL = "users.User"

AUTHENTICATION_BACKENDS = [
    "django.contrib.auth.backends.ModelBackend",
    "allauth.account.auth_backends.AuthenticationBackend",
]

Then we have to tell django-allauth how we’ve set up our custom user model. These settings allow us to use the email field as in lieu of the username, and use the email received from the third party auth systems as such.

# Settings for email as username
ACCOUNT_EMAIL_REQUIRED = True
ACCOUNT_UNIQUE_EMAIL = True
ACCOUNT_AUTHENTICATION_METHOD = "email"
ACCOUNT_USERNAME_REQUIRED = False
ACCOUNT_USER_MODEL_USERNAME_FIELD = None

This has the added advantage of avoiding users creating duplicate accounts. If someone tries to create an account with Twitter, but they already have an account with us with the email address that Twitter provides, they will receive a message reminding them they already have an account. They can then login to the website, and associate their Twitter account with their existing account, if they wish.

Here are some other settings I find useful from django-allauth:

# Email confirmation
ACCOUNT_EMAIL_SUBJECT_PREFIX = "[My Website]"
ACCOUNT_LOGIN_ON_EMAIL_CONFIRMATION = True

# After 10 failed login attempts, restrict logins for 30 minutes
ACCOUNT_LOGIN_ATTEMPTS_LIMIT = 10
ACCOUNT_LOGIN_ATTEMPTS_TIMEOUT = 1800
ACCOUNT_PASSWORD_MIN_LENGTH = 12

# Other settings
ACCOUNT_DEFAULT_HTTP_PROTOCOL = "https"
ACCOUNT_LOGIN_ON_PASSWORD_RESET = True
SOCIALACCOUNT_AUTO_SIGNUP = False

There are many django-allauth settings which can be reviewed to tailor your user experience. I recommend reviewing them.

I haven’t gone into the details of how to set up the third-party providers. There is an excellent tutorial on adding Facebook, and the process is similar for all third party providers.

I hope this walk-through helps get folks off on the right foot. This stuff isn’t easy, but it is very important to get right, at the beginning of a project. I’ve found these settings over many years with several different projects, and hope that experience saves some time for others. Good luck!

I’ve used a lot of editors over the years. Here’s a presentation for co-workers on how I ended up a VSCode enthusiast. If you’d like to learn why I love VSCode so much, check this out.

Current Extensions

• Remote Development (ms-vscode-remote.vscode-remote-extensionpack): https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack
• GitLens (eamodio.gitlens): https://marketplace.visualstudio.com/items?itemName=eamodio.gitlens
• GitHistory (donjayamanne.githistory): https://marketplace.visualstudio.com/items?itemName=donjayamanne.githistory
• Python (ms-python.python): https://marketplace.visualstudio.com/items?itemName=ms-python.python
• Django Templates (batisteo.vscode-django): https://marketplace.visualstudio.com/items?itemName=batisteo.vscode-django
• Beautify (hookyqr.beautify): https://marketplace.visualstudio.com/items?hookyqr.beautify
• ESLint (dbaeumer.vscode-eslint): https://marketplace.visualstudio.com/items?dbaeumer.vscode-eslint

An Example “.vscode/settings.json”

{
    "[python]": {
        "editor.rulers": [
            88
        ],
        "editor.formatOnSave": false,
    },
    "python.pythonPath": "/home/username/.venvs/your-venv/bin/python3",
    "python.formatting.provider": "black",
    "python.linting.enabled": true,
    "python.linting.pylintEnabled": false,
    "python.linting.flake8Enabled": true,
    "python.linting.flake8Args": [
        "--ignore=E203,E231,E309,E501,W503",
        "--max-line-length=88",
        "--verbose"
    ],
    "editor.wordWrapColumn": 88,
    "files.associations": {
        "**/*.html": "html",
        "**/templates/**/*.html": "django-html",
        "**/templates/**/*": "django-txt",
        "**/requirements{/**,*}.{txt,in}": "pip-requirements"
    },
}

An Example “.vscode/launch.json”

You can find details about creating a debugger launch profile here; below is an example of the one I use.

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Python: Django",
            "type": "python",
            "request": "launch",
            "program": "${workspaceFolder}/manage.py",
            "args": [
                "runserver",
                "0:8000",
            ],
            "django": true
        }
    ]
}

Fin.

I hope this helps get you off any running with VSCode for your Python and Django development!

You may have seen my previous posts on this topic, recommending django-pyodbc-azure; it is no longer maintained. We now use django-mssql-backend. Be sure to uninstall all remnants or django-pyodbc-azure; in fact, starting with a fresh virtual environment might be the best bet.

Step 1: Install the Microsoft Linux ODBC Driver

You can also use FreeTDS, but at the time of this writing, I recommend using the Microsoft driver (includes instructions for alternate distributions).

sudo curl https://packages.microsoft.com/config/rhel/7/prod.repo > /etc/yum.repos.d/mssql-release.repo

sudo yum remove unixODBC-utf16 unixODBC-utf16-devel
sudo ACCEPT_EULA=Y yum install msodbcsql17

Step 2: Verify the Installation

If everything worked, you should be able to verify the installation by viewing /etc/odbcinst.ini; it should have a section that looks something like this.

[ODBC Driver 17 for SQL Server]
Description=Microsoft ODBC Driver 17 for SQL Server
Driver=/opt/microsoft/msodbcsql17/lib64/libmsodbcsql-17.1.so.0.1
UsageCount=1

Take note of the section header of the file: ODBC Driver 17 for SQL Server. We will be using this later to reference the driver.

Step 3: Setting Up a Service User in SQL Server

For best security practices, I recommend setting up an individual user for each Django project you have. The following script will create a DATABASE, LOGIN, USER and PASSWORD in SQL Server with the minimum permissions needed for Django to run.

/*
This Script Creates a SQL Server Database, Login and User
With Appropriate Permissions for a Production Django Project
with migrations. Simply fill out the variables below (@db_name and @db_password)
Username will be set to database name + '_user' by default.
*/
DECLARE @db_name VARCHAR(MAX) = 'project'
DECLARE @db_password VARCHAR(MAX) = 'project_password'
DECLARE @db_user VARCHAR(MAX) = @db_name + '_user'
--
--
USE master
DECLARE @cmd VARCHAR(MAX)
-- Server scope: create SQL Server login and permissions
SET @cmd = 'CREATE LOGIN ' + @db_user + ' WITH PASSWORD = ''' + @db_password + ''''
EXEC(@cmd)
SET @cmd = 'GRANT VIEW SERVER STATE TO ' + @db_user
EXEC(@cmd)
SET @cmd = 'CREATE DATABASE [' + @db_name + ']'
EXEC(@cmd)
-- DB scope: create user for server login and permissions
SET @cmd = 'USE [' + @db_name + '];'
SET @cmd = @cmd + 'CREATE USER ' + @db_user + ' FOR LOGIN ' + @db_user + ';'
SET @cmd = @cmd + 'GRANT SELECT, INSERT, UPDATE, DELETE, ALTER, CREATE TABLE, REFERENCES, EXEC TO ' + @db_user
EXEC(@cmd)

Step 4: Setting up Django

Fire up your virtual environment for your Django project. We’re going to install django-mssql-backend (which will install pyodbc as well).

pip install django-mssql-backend

Then, we modify our Django settings.

DATABASES = {
    'default': {
        'ENGINE': 'sql_server.pyodbc',
        'HOST': 'dbserver.your-domain.com',
        'PORT': '1433',
        'NAME': 'project',
        'USER': 'project_user',
        'PASSWORD': 'project_password',
        'OPTIONS': {
            'driver': 'ODBC Driver 17 for SQL Server',
            'unicode_results': True,
        },
    },
}

Step 5: Run Initial Migrations

If everything has worked, you should now be able to run your initial migrations, and see Django’s initial tables in your SQL Server database. If you have any questions, there are a bunch of us who watch the django-mssql-backend tag on Stack Overflow and willing to help!

Wagtail 1.0 was released five years ago, and since then, it has emerged as the most popular CMS for the Django web framework. Wagtail and Django are both written in Python, one of the most popular programming languages and ecosystems in the world. Django powers sites like Instagram, Pinterest, The Washington Post, and Wagtail is used by major players like the U.K.’s National Health System, Google’s blog, The Wharton School, several of NASA’s sites, and many more. Wagtail takes a different approach from most CMS’s: there’s no quick start installation, and you will need a developer. Wagtail challenges you to think of the shape and structure of your content up front, but is flexible enough to adapt as your content needs change.

Accessibility, user experience, search, and scalability aren’t afterthoughts in Wagtail: they are first order features. Wagtail also features a mobile friendly admin designed by content creators, a StreamField for structured authorship to avoid overloading a body field, and beautiful WYSIWYG called Draftail. Draftail stores all of its content in a JSON structured format rather than raw HTML, avoiding the many back-and-forth conversion problems prevalent in WYSIWYGs.

Tom will give an introduction to Wagtail, its philosophy, and why his Drupal shop decided to pivot from PHP to create a Python/Django based framework. Tim will show how it is being used to save lives here in Philadelphia, by powering our regional A.A. website.