Pride Vibes 2017: Coventry Pride

Samathy from Stories by Samathy on Medium

Laura Tapp performs on Saturday evening at Coventry Pride

Pride Vibes: As a photographer for Gay Pride Pics, I see lots of Prides across the UK every year. Each Pride has a different feel. This series will describe what each Pride was like and what the vibe of the pride was like.

The entire series is my opinion and mine only. Take it as you will. Note that this opinion comes from a 20 something extroverted transwoman who is herself a pride organiser.

I’m still working out what this series is going to be like. Bear with me.

Full Disclosure: I am a trustee and organiser of Coventry Pride. I work specifically on Press and Publicity. This post will be more biased than normal.

Previous: Birmingham Pride

Coventry Pride is in its 3rd year. It’s a smallish pride with a big personality. It brands itself as a ‘Community Pride’ and makes a huge effort to welcome all members of the extended LGBTQIA+ community.

Coventry is a completely free pride welcoming attendees in to a new venue in the centre of the city, University Square.
The venue is much larger than the previous at FarGo Village allowing for massive expansion this year.

Situated right outside the iconic dual Cathedrals the new venue proved much better than last year.
It’s a much bigger space and the event felt very open and a lot less crowded than last year’s pride.
Although, it certainly didn't feel packed, it certainly felt buzzing with happy energy.

The main stage was fairly large and could be seen and heard throughout most of the main square area. Most of the acts proved to be a great success with the audience.
Most of them were musical acts with a smattering of comedy, with the drag acts largely kept to the cabaret stage which is inside Square One, the Coventry University Student’s Union bar and club.

The main square area also featured a bar, which, despite its central location did not result in large amounts of drunk people making me feel uncomfortable.
In fact, I don’t think I saw anyone I would be able to describe as anything other than sober. Which, for me is a good thing.

The supporting stages in Square One featured smaller musical acts and community comedy performances.
Welcomed there were a host of great acoustic musical performances, drag and both small-time and big-time comedy.

The supporting stages welcomed smaller, intimate performances.

The diversity of the event was wonderful.
Being a free event, Coventry Pride is lucky to be able to be open to people of all ages and orientations.
There were lots of families and younger people attending, which was fantastic to see and really helps with the open and welcoming feel of the event.
We saw young and old people attending and having fun. Most importantly we saw people from so many identities! At least, as far as I could tell from the flags people were wearing.
This really helped me and a lot of my friends feel included in the event. The presence of such a diverse set of people really supported the comfortable feeling of a space where one could be themselves without worry.

As well as the outside main area, we also had an inside arrangement of community stalls.

The community stalls were a huge part of the event.

The stalls were as diverse as the attending crowd. We had everything from stalls selling art, offering counselling services, information about scouting, LGBT+ identities and so much more.
We’re really pleased with the amount of community stalls we had and they really helped to maintain the vibe that Coventry Pride aims for. People supporting other people.

The stalls were located inside The Herbert Art Gallery and Museum which proved to be a near perfect venue.

The Herbert provided their huge atrium space for the community stalls which offered a lot of space for attendees to peruse the stalls at their leisure.
The Herbert also offered their gender neutral toilets for Coventry Pride attendees, which was a great bonus to go along with the portaloos and toilets in the University SU.

One thing I noticed at the event was the policing, or lack of.
There were officers at the event and around the surrounding area, but they felt much more like participants in the event rather than bystanders.
We saw officers taking photos, talking to stall holders and seemingly having a great time, just like everyone else.

The police were as much participants as everyone else.

The Sargent on duty on Saturday was a great guy who was super interested in learning as much about the LGBT+ community as he could, asking polite questions when appropriate. He even requested to be posted at Coventry Pride on the Sunday too because he enjoyed the event so much.

A huge event at Coventry Pride 2017 was The Blessing of Haley Bridge and Claire Haines.

Haley and Claire were married earlier on the Sunday at the Guild Hall just up the road from University Square.
Following their wedding, we welcomed the beautiful brides to Coventry Pride and the Chair of Coventry Pride, Paul Desson-Baxter, blessed the wedding in front of 100s of people.

The blessing was a beautiful event. It truly was wonderful to see two women married and celebrate their marriage at a Pride event.

All in all, Coventry Pride was a fantastic event. We’re super happy to have been able to offer an event welcoming such a diverse selection of people from our community.
We’re glad that we’re able to offer the event for free to everyone who wants to come, giving access to all those who need a Pride in their local area.

As always, the volunteers and organisers of Coventry Pride did an amazing job and put in an awful lot of effort to make it happen.

Know your hammer from your screwdriver: The right tool for the job

Paul Grenyer from Paul Grenyer

As software developers, we at Naked Element, are skilled and experienced in a number of different programming languages and aware of many, many more. Choosing the right programming language for a piece of software is as important as choosing a hammer to knock in a nail, a flat headed screw driver for a flat headed screw and a cross headed screwdriver for cross headed screw. However with software it’s far more complicated as there isn’t always just one tool for the job.

It’s also important to consider the skills you have at hand. For example, you wouldn’t usually ask a plumber to fix your electrics or an electrician to fix your plumbing. However, given enough time most plumbers could learn to do electrics and vice versa. Generally people with a talent for practical things can easily pick up other practical skills. It’s the same with software developers, but you have to consider whether the investment in new skills will return sufficient results in an acceptable time frame, or whether to risk compromising your margins by bringing in already experienced outside help. It’s not an easy decision!

Software developers (the good ones at least) love learning new things - programming languages in particular - but there are divisions of course. Some software developers are only interested in writing software for Microsoft Windows, for example, or for Open Source platforms such as Linux and the tools they use are quite different. It’s even more pronounced with Android developers and iPhone developers! You don’t often get developers who like a bit of everything, but it does happen, and those are the sorts of developers we have at Naked Element.

It’s true that we’d happily write Java (a general purpose programming language aimed at open source software development) all day long, but that wouldn’t allow us to develop complete pieces of software. We regularly use various combinations of Java, Ruby on Rails and JavaScript in order to get the best result. We’ve turned our hand to Python and, more recently, Microsoft core languages such as C# and VB.net too. It depends what our clients need and our assessment of the right tool for the job. Sometimes it’s not even about choosing a programming language. Sometimes it’s about choosing pre-built software, such as Wordpress, and customising it to our client’s needs. We wouldn’t use Wordpress for anything more complicated than a simple e-commerce system, but for websites, including ours, it’s the right tool for the job.

So when you’re choosing your software development partner, consider whether they’re using the right tools for your project or whether they’re just using the hammer they’re familiar with to knock in your screw.

Stack Overflow With Custom JsonConverter

Chris Oldwood from The OldWood Thing

[There is a Gist on GitHub that contains a minimal working example and summary of this post.]

We recently needed to change our data model so that what was originally a list of one type, became a list of objects of different types with a common base, i.e. our JSON deserialization now needed to deal with polymorphic types.

Naturally we googled the problem to see what support, if any, Newtonsoft’s JSON.Net had. Although it has some built-in support, like many built-in solutions it stores fully qualified type names which we didn’t want in our JSON, we just wanted simple technology-agnostic type names like “cat” or “dog” that we would be happy to map manually somewhere in our code. We didn’t want to write all the deserialization logic manually, but was happy to give the library a leg-up with the mapping of types.

JsonConverter

Our searching quickly led to the following question on Stack Overflow: “Deserializing polymorphic json classes without type information using json.net”. The lack of type information mentioned in the question meant the exact .Net type (i.e. name, assembly, version, etc.), and so the answer describes how to do it where you can infer the resulting type from one or more attributes in the data itself. In our case it was a field unsurprisingly called “type” that held a simplified name as described earlier.

The crux of the solution involves creating a JsonConverter and implementing the two methods CanConvert and ReadJson. If we follow that Stack Overflow post’s top answer we end up with an implementation something like this:

public class CustomJsonConverter : JsonConverter
{
  public override bool CanConvert(Type objectType)
  {
    return typeof(BaseType).
                       IsAssignableFrom(objectType);
  }

  public override object ReadJson(JsonReader reader,
           Type objectType, object existingValue,
           JsonSerializer serializer)
  {
    JObject item = JObject.Load(reader);

    if (item.Value<string>(“type”) == “Derived”)
    {
      return item.ToObject<DerivedType>();
    }
    else
    . . .
  }
}

This all made perfect sense and even agreed with a couple of other blog posts on the topic we unearthed. However when we plugged it in we ended up with an infinite loop in the ReadJson method that resulted in a StackOverflowException. Doing some more googling and checking the Newtonsoft JSON.Net documentation didn’t point out our “obvious” mistake and so we resorted to the time honoured technique of fumbling around with the code to see if we could get this (seemingly promising) solution working.

A Blind Alley

One avenue that appeared to fix the problem was manually adding the JsonConverter to the list of Converters in the JsonSerializerSettings object instead of using the [JsonConverter] attribute on the base class. We went back and forth with some unit tests to prove that this was indeed the solution and even committed this fix to our codebase.

However I was never really satisfied with this outcome and so decided to write this incident up. I started to work through the simplest possible example to illustrate the behaviour but when I came to repro it I found that neither approach worked – attribute or serializer settings - I always got into an infinite loop.

Hence I questioned our original diagnosis and continued to see if there was a more satisfactory answer.

ToObject vs Populate

I went back and re-read the various hits we got with those additional keywords (recursion, infinite loop and stack overflow) to see if we’d missed something along the way. The two main candidates were “Polymorphic JSON Deserialization failing using Json.Net” and “Custom inheritance JsonConverter fails when JsonConverterAttribute is used”. Neither of these explicitly references the answer we initially found and what might be wrong with it – they give a different answer to a slightly different question.

However in these answers they suggest de-serializing the object in a different way, instead of using ToObject<DerivedType>() to do all the heavy lifting, they suggest creating the uninitialized object yourself and then using Populate() to fill in the details, like this:

{
  JObject item = JObject.Load(reader);

  if (item.Value<string>(“type”) == “Derived”)
  {
    var @object = new DerivedType();
    serializer.Populate(item.CreateReader(), @object);
    return @object;
  }
  else
    . . .
}

Plugging this approach into my minimal example worked, and for both the converter techniques too: attribute and serializer settings.

Unanswered Questions

So I’ve found another technique that works, which is great, but I still lack closure around the whole affair. For example, how come the answer in the the original Stack Overflow question “Deserializing polymorphic json classes” didn’t work for us? That answer has plenty of up-votes and so should be considered pretty reliable. Has there been a change to Newtonsoft’s JSON.Net library that has somehow caused this answer to now break for others? Is there a new bug that we’ve literally only just discovered (we’re using v10)? Why don’t the JSON.Net docs warn against this if it really is an issue, or are we looking in the wrong part of the docs?

As described right at the beginning I’ve published a Gist with my minimal example and added a comment to the Stack Overflow answer with that link so that anyone else on the same journey has some other pieces of the jigsaw to work with. Perhaps over time my comment will also acquire up-votes to help indicate that it’s not so cut-and-dried. Or maybe someone who knows the right answer will spot it and point out where we went wrong.

Ultimately though this is probably a case of not seeing the wood for the trees. It’s so easy when you’re trying to solve one problem to get lost in the accidental complexity and not take a step back. Answers on Stack Overflow generally carry a large degree of gravitas, but they should not be assumed to be infallible. All documentation can go out of date even if there are (seemingly) many eyes watching over it.

When your mind-set is one that always assumes the bugs are of your own making, unless the evidence is overwhelming, then those times when you might actually not be entirely at fault seem to feel all the more embarrassing when you realise the answer was probably there all along but you discounted it too early because your train of thought was elsewhere.

Sign on the Dotted Line – Why Contracts are Important

Paul Grenyer from Paul Grenyer

Contracts might seem like something only big business needs, and many small companies work without them, but if your work is important to you, it is vital to have a contract in place. A well put together contract can make a business relationship stronger and more successful, so it is worth investing some time and effort in getting a contract just right.

When people think of contracts, they often seem daunting, filled with complicated language only solicitors understand, fine print made to confuse the signatory and seemingly endless clauses that only apply in the most unique of circumstances. Documents like this are off putting, and occasionally detrimental to the business process, especially at the beginning of a new working relationship. Contracts don’t need to be pages and pages long, or contain lots of legal jargon or penalties, the most important thing is that all parties understand the content of the contract and all are in agreement as to their own responsibilities. It is very important to make clear what is expected of each party and what will happen if either side fails to keep up their end of the agreement. Being clear on cost is essential too - what is included in the charge and, very importantly, what is not included. A good contract should only contain information relevant to that particular piece of work and should be written in simple, understandable language where possible. Having someone sign something they don’t understand is not a good way to begin!

For general terms of business, applicable to every piece of work, a Master Service Agreement can prove useful to accompany each specific work contract and Naked Element agrees and signs an MSA with every client. This MSA does not oblige either party to work with each other, it merely details the quality of the service or product, each party’s availability throughout the business relationship and the responsibilities they have to each other. Only once a schedule is signed, does it become a binding contract. The MSA defines the confidentiality clauses, copyright details, intellectual property rights, payment terms and the scope of charges as well as liability from each party. These key details are indispensable for any business, whether the project is worth £500 or £5,000,000 as they are crucial if something were to go wrong.

Contracts also shouldn’t be designed to catch someone out, or tie them down unnecessarily, they should be an agreement, put together for the benefit of all parties. Where possible, a clever business person should be open to discussing and amending a proposed contract before it is signed if the other party wishes to make changes. It is also often beneficial to include a clause allowing either party to revisit a contract for adjustment after a set period of time. Being flexible and open to future issues in this way increases trust between parties, making a successful business relationship more likely.

A good contract should -

  • Only include relevant information
  • Use simple language
  • Outline benefits of the contract to both parties
  • Be negotiable
  • Be adjustable where appropriate

With a proper contract the client will feel they can depend on the product or service they are paying for and can rely on the contract to ensure they will not be out of pocket if something goes awry. By the same token, the service provider is protected by the contract if a client should renege on something that was previously mutually agreed upon. A good contract, that has everyone's  interests covered equally, makes a business seem more trustworthy, as well as more professional, and if everything goes well, more likely to do business again.

Words by Lauren.

Making 100 million requests with Python aiohttp

Andy Balaam from Andy Balaam&#039;s Blog

Series: asyncio basics, large numbers in parallel, parallel HTTP requests, adding to stdlib

I’ve been working on how to make a very large number of HTTP requests using Python’s asyncio and aiohttp.

Paweł Miech’s post Making 1 million requests with python-aiohttp taught me how to think about this, and got us a long way, with 1 million requests running in a reasonable time, but I need to go further.

Paweł’s approach limits the number of requests that are in progress, but it uses an unbounded amount of memory to hold the futures that it wants to execute.

We can avoid using unbounded memory by using the limited_as_completed function I outined in my previous post.

Setup

Server

We have a server program “server”:

(Note it differs from Paweł’s version because I am using an older version of aiohttp which has fewer convenient features.)

#!/usr/bin/env python3.5

from aiohttp import web
import asyncio
import random

async def handle(request):
    await asyncio.sleep(random.randint(0, 3))
    return web.Response(text="Hello, World!")

async def init():
    app = web.Application()
    app.router.add_route('GET', '/{name}', handle)
    return await loop.create_server(
        app.make_handler(), '127.0.0.1', 8080)

loop = asyncio.get_event_loop()
loop.run_until_complete(init())
loop.run_forever()

This just responds “Hello, World!” to every request it receives, but after an artificial delay of 0-3 seconds.

Synchronous client

As a baseline, we have a synchronous client “client-sync”:

#!/usr/bin/env python3.5

import requests
import sys

url = "http://localhost:8080/{}"
for i in range(int(sys.argv[1])):
    requests.get(url.format(i)).text

This waits for each request to complete before making the next one. Like the other clients below, it takes the number of requests to make as a command-line argument.

Async client using semaphores

Copied mostly verbatim from Making 1 million requests with python-aiohttp we have an async client “client-async-sem” that uses a semaphore to restrict the number of requests that are in progress at any time to 1000:

#!/usr/bin/env python3.5

from aiohttp import ClientSession
import asyncio
import sys

limit = 1000

async def fetch(url, session):
    async with session.get(url) as response:
        return await response.read()

async def bound_fetch(sem, url, session):
    # Getter function with semaphore.
    async with sem:
        await fetch(url, session)

async def run(session, r):
    url = "http://localhost:8080/{}"
    tasks = []
    # create instance of Semaphore
    sem = asyncio.Semaphore(limit)
    for i in range(r):
        # pass Semaphore and session to every GET request
        task = asyncio.ensure_future(bound_fetch(sem, url.format(i), session))
        tasks.append(task)
    responses = asyncio.gather(*tasks)
    await responses

loop = asyncio.get_event_loop()
with ClientSession() as session:
    loop.run_until_complete(asyncio.ensure_future(run(session, int(sys.argv[1]))))

Async client using limited_as_completed

The new client I am presenting here uses limited_as_completed from the previous post. This means it can make a generator that provides the futures to wait for as they are needed, instead of making them all at the beginning.

It is called “client-async-as-completed”:

#!/usr/bin/env python3.5

from aiohttp import ClientSession
import asyncio
from itertools import islice
import sys

def limited_as_completed(coros, limit):
    futures = [
        asyncio.ensure_future(c)
        for c in islice(coros, 0, limit)
    ]
    async def first_to_finish():
        while True:
            await asyncio.sleep(0)
            for f in futures:
                if f.done():
                    futures.remove(f)
                    try:
                        newf = next(coros)
                        futures.append(
                            asyncio.ensure_future(newf))
                    except StopIteration as e:
                        pass
                    return f.result()
    while len(futures) > 0:
        yield first_to_finish()

async def fetch(url, session):
    async with session.get(url) as response:
        return await response.read()

limit = 1000

async def print_when_done(tasks):
    for res in limited_as_completed(tasks, limit):
        await res

r = int(sys.argv[1])
url = "http://localhost:8080/{}"
loop = asyncio.get_event_loop()
with ClientSession() as session:
    coros = (fetch(url.format(i), session) for i in range(r))
    loop.run_until_complete(print_when_done(coros))
loop.close()

Again, this limits the number of requests to 1000.

Test setup

Finally, we have a test runner script called “timed”:

#!/usr/bin/env bash

./server &
sleep 1 # Wait for server to start

/usr/bin/time --format "Memory usage: %MKB\tTime: %e seconds" "$@"

# %e Elapsed real (wall clock) time used by the process, in seconds.
# %M Maximum resident set size of the process in Kilobytes.

kill %1

This runs each process, ensuring the server is restarted each time it runs, and prints out how long it took to run, and how much memory it used.

Results

When making only 10 requests, the async clients worked faster because they launched all the requests simultaneously and only had to wait for the longest one (3 seconds). The memory usage of all three clients was fine:

$ ./timed ./client-sync 10
Memory usage: 20548KB	Time: 15.16 seconds
$ ./timed ./client-async-sem 10
Memory usage: 24996KB	Time: 3.13 seconds
$ ./timed ./client-async-as-completed 10
Memory usage: 23176KB	Time: 3.13 seconds

When making 100 requests, the synchronous client was very slow, but all three clients worked eventually:

$ ./timed ./client-sync 100
Memory usage: 20528KB	Time: 156.63 seconds
$ ./timed ./client-async-sem 100
Memory usage: 24980KB	Time: 3.21 seconds
$ ./timed ./client-async-as-completed 100
Memory usage: 24904KB	Time: 3.21 seconds

At this point let’s agree that life is too short to wait for the synchronous client.

When making 10000 requests, both async clients worked quite quickly, and both had increased memory usage, but the semaphore-based one used almost twice as much memory as the limited_as_completed version:

$ ./timed ./client-async-sem 10000
Memory usage: 77912KB	Time: 18.10 seconds
$ ./timed ./client-async-as-completed 10000
Memory usage: 46780KB	Time: 17.86 seconds

For 1 million requests, the semaphore-based client took 25 minutes on my (32GB RAM) machine. It only used about 10% of my CPU, and it used a lot of memory (over 3GB):

$ ./timed ./client-async-sem 1000000
Memory usage: 3815076KB	Time: 1544.04 seconds

Note: Paweł’s version only took 9 minutes on his laptop and used all his CPU, so I wonder whether I have made a mistake somewhere, or whether my version of Python (3.5.2) is not as good as a later one.

The limited_as_completed version ran in a similar amount of time but used 100% of my CPU, and used a much smaller amount of memory (162MB):

$ ./timed ./client-async-as-completed 1000000
Memory usage: 162168KB	Time: 1505.75 seconds

Now let’s try 100 million requests. The semaphore-based version lasted 10 hours before it was killed by Linux’s OOM Killer, but it didn’t manage to make any requests in this time, because it creates all its futures before it starts making requests:

$ ./timed ./client-async-sem 100000000
Command terminated by signal 9

I left the limited_as_completed version over the weekend and it managed to succeed eventually:

$ ./timed ./client-async-as-completed 100000000
Memory usage: 294304KB	Time: 150213.15 seconds

So its memory usage was still very bounded, and it managed to do about 665 requests/second over an extended period, which is almost identical to the throughput of the previous cases.

Conclusion

Making a million requests is usually enough, but when we really need to do a lot of work while keeping our memory usage bounded, it looks like an approach like limited_as_completed is a good way to go. I also think it’s slightly easier to understand.

In the next post I describe my attempt to get something like this added to the Python standard library.

The Kings of Leon

Paul Grenyer from Paul Grenyer

Sheffield is in the North and things, well people, are very different in the North. They’re friendlier than other places. They apologise in a friendly way when they knock into you and several people run after your ticket when it blows away in the wind after you’ve been through security.

Given the recent events in Manchester security was tight at Sheffield Arena. There were plenty of police, some of them visibly armed. You weren’t allowed to take in a bag any bigger than A4 and everyone was searched before they could enter the arena foyer. Having said that, we had no problems parking (getting out of the car park was a different matter) and were through the security check in no time. Everyone there, including the security, was friendly! Even the armed police were posing for selfies and chatting at the end of the night.

I’m not a fan of the Kings of Leon. They’ve got a few good songs, I mean who doesn’t like having their sex on fire? I find them bland, monotonous and a bit boring. Live it’s a different story. They’ve still only got one sound, but it’s much more palatable and they’re very good at it. The lead guitarist can play, but is nothing special, the bass player looks like Billy Idol on a good day and the drummer spent most of the show chewing gum and blowing bubbles, but the singer, his range and the effortless delivery were incredible. He just needs to work on his interaction and eye contact with the crowd.


What was also quite cool was, about halfway through, a complete stage rearrange, the moving of the drum riser and the introduction of a third guitarist and a keyboard player all performed behind a curtain with sometimes just the front man and sometimes all of the main band playing out the front. It was fun, exciting and interesting to see.

They played most of the hits, as far as I could tell and didn’t do an encore, which always makes things easier and means you get more music and less messing around.



Python – printing UTC dates in ISO8601 format with time zone

Andy Balaam from Andy Balaam&#039;s Blog

By default, when you make a UTC date from a Unix timestamp in Python and print it in ISO format, it has no time zone:

$ python3
>>> from datetime import datetime
>>> datetime.utcfromtimestamp(1496998804).isoformat()
'2017-06-09T09:00:04'

Whenever you talk about a datetime, I think you should always include a time zone, so I find this problematic.

The solution is to mention the timezone explicitly when you create the datetime:

$ python3
>>> from datetime import datetime, timezone
>>> datetime.fromtimestamp(1496998804, tz=timezone.utc).isoformat()
'2017-06-09T09:00:04+00:00'

Note, including the timezone explicitly works the same way when creating a datetime in other ways:

$ python3
>>> from datetime import datetime, timezone
>>> datetime(2017, 6, 9).isoformat()
'2017-06-09T00:00:00'
>>> datetime(2017, 6, 9, tzinfo=timezone.utc).isoformat()
'2017-06-09T00:00:00+00:00'

Pride Vibes 2017: Birmingham Pride

Samathy from Stories by Samathy on Medium

Marching in Birmingham’s Parade

Pride Vibes: As a photographer for Gay Pride Pics, I see lots of Prides across the UK every year. Each Pride has a different feel. This series will describe what each Pride was like and what the vibe of the pride was like.

The entire series is my opinion and mine only. Take it as you will. Note that this opinion comes from a 20 something extroverted transwoman who is herself a pride organiser.

I’m still working out what this series is going to be like. Bear with me.

Next: Coventry Pride
Previous: Exeter Pride

Birmingham Pride is the biggest Pride in West Midlands. Its one of the biggest in the UK too, competing directly with the likes of Manchester, London and Brighton.
It draws a totally different crowd to that of smaller, community Prides like Exeter, Coventry and Harrogate, for example.

Birmingham Pride is a very extravagant Pride, with costs in the range of several £100,000's.

Birmingham’s parade featured big companies.

Birmingham’s Parade is a huge affair. It features 10s of organisations from big corporate companies like Asda and Virgin to charities like Birmingham LGBT and Stonewall.
Birmingham’s parade also features a lot of Students, given that each one of its Universities were represented there.

Christians and other religious organisations were represented.

Despite the size of the parade through Birmingham, everyone who walked in it was with some kind of organisation. Everyone was there to represent someone.
Like most bigger pride parades, with Birmingham you’re required to register your marching group and identify roughly how many people are walking with you.
Such a practice prevents the more organic ‘marching for pride’ that you get with smaller Parades.

The result is a parade that features a lot more older people associated with their companies and organisations. Which is great for seeing just how many companies support the Pride movement, but not great if you simply want to join in the march and stand up for what you believe in.

Birmingham Pride does however, feature protesting groups.
There were several groups chanting in protest of current issues.
Stand out groups included a several religious groups, Out in the UK (LGBT+ Asylum seekers), and of course Black Lives Matter.

It was great that Birmingham’s pride march supports protesting groups and is clearly in favour of providing the platform for Pride as A Protest.
It really felt like Birmingham Pride’s parade is a good balance of Pride as a celebration and show of big society support and Pride as a Protest march aimng to raise awareness of issues we still face.

People used Birmingham Pride’s parade as a protest platform.

Birmingham’s large Pride parade draws people out onto the streets.
The whole parade route is lined with people who, despite not being in the parade itself, are just as involved.

The people of Birmingham and the West Midlands seem to make a decisive effort to come out and see and support the Pride Parade.
It creates a busy atmosphere, but in my opinion its not necessarily one of support for the causes.
I felt like a lot of people watching were watching simply for the spectacle of seeing a Pride, rather than because they whole heartily support the Pride movement.
Not that there were not lots of people who clearly supported the movement too, mind.

The Gay Village at Birmingham Pride is a rather different experience to the free Prides in the UK.

At £22 for a standard entry ticket, lots of people are deterred from entering the branded ‘Gay Village’. A naming I Strongly disagree with.
I noted, that as soon as the parade broke away and the village opened, the type of people around suddenly changed and the vibe pivoted to something completely different.

Instead of feeling like I was on a semi-protest march for LGBT+ rights, I was now in some alcohol and nicotine fueled festival that seemed to have absolutely no purpose except to provide a reasonably cheap way of seeing lots of musical artists in one place.

For me, as soon as we went into the village area the Pride lost all sense of, well, Pride.
The people there completely changed, there were practically no young people at all around. Suddenly a huge amount of straight people arrived, and I noticed a sharp decline in the amount of people of colour. I even spotted a couple of hen parties (not that hen parties are bad, but it felt exploitative of the Pride movement).

Thats not to say ALL people from the parade left. This photo of a fetish (?) man getting his face painted highly amuses me.

There were clearly people having fun, and at the start, Idid enjoy seeing so many people meeting their friends and having a jolly gay time.

But as the day drew on, the haze of cigarette smoke increased over the absolutely packed venue area.
I was struggling to move around, I struggled to breath properly and I started to feel very uncomfortable presenting as myself. Entirely not what I expected from an event branding itself as a Pride.

In general, for me, the vibe went from feeling like a reasonably inclusive Pride to feeling like a hell hole of drunk people whome I was not safe around.

Your mileage may vary on this! Its totally possible that I felt uncomfortable because I was not with friends, I was not drinking and I was not particularly enthused by any of the acts on.

Clearly, there were lots of people having a great time in Birmingham Pride’s gay village, and I don’t believe that its going to be a terrible experience for everyone.

Birmingham Pride does provide a fantastic set of acts on a number of stages with some great venues in which to have a fun old time with your favourite people.

They do a great job of making your £22 ticket go a long way too.

Despite my compaints about the event, I’d like to congratulate the the Birmingham Pride committee and all the volunteers on pulling off its largest Pride yet!

Like all Prides, its unique and special in its own way.

I await seeing next years Pride.

Volunteers at Birmingham Pride.