This weekend, I went to the BarCamp Birmingham event.

BarCamp is organised by FLOSS UK (Free Libre Open Source Software) and is run in an unconference style, much like our monthly engineering openspaces, people write down on Post-It notes something they'd be prepared to talk about or that they'd like to learn about, then they're voted on and talks are done in order of everyone's preferences.

It's a single day event, running from 10am to 5pm with about 30 attendees, followed by a pub trip afterwards. Unusually, for this kind of event it's free and food is provided. The venue has been the same for the last few years, just a few minutes walk from New Street station in Birmingham. There's a bit more information available at http://www.flossuk.org/events/barcamp-birmingham/

The talk structure is roughly 20 minutes including Q&A, although some of the things people want to learn about are done instead as a BOF group (Birds Of a Feather) where 3 or 4 people chat together whilst other people are in different groups or eating lunch etc. Some people have presentations they've used elsewhere, others were totally off the cuff.

In previous years, there was a lot more focus on open source, this year it felt more like it was related to people's interests and current projects. There's a heavy UNIX bias though, I think I was the only one with a Windows laptop for instance!

Talk 1 - Tactile Internet (Indria)

This was a talk from someone who'd just joined a research group a few weeks ago looking at low latency remote working, so things like surgeons operating in different countries to the patient, etc. Think like a bomb defusal robot except a lot more realtime and tactile feedback, e.g. being able to feel the knife you've just picked up, and quick response.

Interestingly, this all seems to be based on 5G phone tech and is aiming for 1ms round-trip time (which is amazing given the expectation that this would work across the globe). Lots of stuff from routing problems like reducing the size of packet headers to reduce latency, to high availability, to just how to have the correct physical response so a real-life expert isn't impeded, etc.

Talk 2 - Cloud ABI (Alex Willmer @moreati)

Describing managing "capabilities" in operating systems, to enable trust of downloaded executables.

Based on "capsicum" project for FreeBSD, see https://github.com/NuxiNL

Idea is essentially to remove system calls from OS layers, so e.g. the executable is passed already open file handles or a filehandle to a directory rather than a filename and have it open the right itself.

Goes beyond FreeBSD's pledge() call because it's not opt-in and the library functions aren't even available at compile time, making it harder to accidentally use unsafe APIs.
Implemented on Linux via binfmt_misc (a way of emulating different OS personalities)
It wasn't explicitly mentioned in the talk, but I thought there were good parallels for TDD and injection too.

Talk 3 - Hacking your body (Adam Sweet)

A compressed version of the hour talk he gave at Oggcamp in Oxford a year or two ago (also a great event!)

He just covered diet in this, not the fitness part and how to look after your back, that he covered then.

Basically, fat doesn't make you fat, sugar does.

He went less far than the low-carb books I've read, he advocates just a balanced mix of protein, carbs and fat, and his main emphasis is on cooking your own food rather than buying stuff with things added to make them taste more appealing (usually sugar!)

Talk 4 - Demoscene (Ralf)

I gave a talk about the demoscene.

Started off by showing them Gaia Machine by Approximate which won the 64KB compo in Revision 2012. Afterwards I asked them to guess how big the code was for the 4:30 demo. A few people jumped the gun at 4KB!

I also showed them a quick snippet of Felix's Workshop which came 2nd in the same 64KB compo to show them that small demos weren't always really abstract.

After talking a bit about PC demos and the different types of compo (4KB, 16KB, music, unlimited), I then mentioned others like retro and wild and showed a snippet from my Breaking Baud demo.

Talk 5 - Agile (Steve Pitchford @stevejpitchford)

He gave a talk on Agile development, focussed mainly on how Agile is usually applied as a set of rules to follow rather than as a bias towards agile methods, and how a lot of projects fail because they try to throw out their old style of working as well. He pointed out that the most common word in the Agile Manifesto is over, as in "we value X over Y", not "do X not Y".

He mentioned Herzberg's two-factor theory as an advanced form of the Maslov's hierarchy of needs that most of us are familiar with; essentially what motivates and demotivates people in work.

Talk 6 - Animation using Continuous Integration (Mike Hingley @computa_mike)

Mike and his brother had created a children's animation based on a story from a 7-year old kid, about a dragon who stole the Queen's money and featured a cat detective!

The animation was created entirely using open source software and had decided to use continuous integration (Jenkins CI) to render the animation on commits.

He mentioned some of the technical hurdles - Kdenlive used absolute paths, so needed a helper program to be written to modify the paths before commit and after getting latest, and moving to incremental renders where only modified scenes were re-rendered on commit and injected to the correct place in the animation.

They used git, but didn't have large binaries as their files were mostly XML 2D SVG, but his brother was new to git and used git-cola which they found gave him a very good process and way into git.

The animation itself was made with Synfig

All of his animation source assets are open and available on github

Talk 7 - Databases (Brian Walker)

Brian works for HSBC as a DBA responsible for some massive databases, e.g. a 75TB database held across 6 servers, and described some of the thought processes he went through when somebody asked him to spec out hardware for a database.

The example he used was a 2TB database. I forgot to make detailed notes, but some of the considerations were:

Roughly another 500MB for temporary space was needed - database performance would be massively reduced without the extra space for the DB to use when regenerating indices etc.

He would typically start with 6 PCI slots and 6 drive bays, and use 2 drives for tables and 1 for database indexing use. Those 2 table drives would be either primary or secondary tables or split between primarily read and primarily write with a slower background process shunting new data to the read disk. He'd then use the other 3 drives to do RAID on the data.

Talk 8 - Calendar integration with Office 365 (John Knight)

He was focussed on the Graph API, which is RESTful, but said that it's actually the same API as shared with OneDrive, the Directory Service, etc.

Turns out to be remarkably easy, also the OAuth2 tokens can be used with the other protocol (I wasn't paying enough attention here!) and also commented that whilst there was both a released and a beta API, and they both kind of worked, they were both felt a bit alpha quality in that he was never really sure if something would work or not without trying it. But on the whole, it was successful and they imported something like 10,000 users worth of calendars this way.

There was a comment about not having permissions to do certain operations because even though the systems admin had set the policy to allow it, because the user can't given authentication they couldn't do some operations. Apparently this is a bug that is being fixed, but until then it's hard to do some things on their user's behalf.

Talk 9 - The Julia programming Language (Keith)

Seems like an interesting language that's gaining popularity with scientific users, being faster than Fortan and not much slower than C.

The official website is http://julialang.org/

There's a sandbox where you can play with the language over the web with no installation, https://juliabox.org/ which itself seems to have been built with Jupyter Notebook.

The language itself seems quite dynamic and has a whole load of libraries for numerical simulation, stats and plotting graphs etc that seem pretty trivial to use.

There's an interactive REPL for trying out ideas and it seems to use LLVM for the original purpose, as a low-level virtual machine, so it can compile quickly but also optimise programs on the fly as the execution hotspots are discovered.

SageMathCloud was mentioned, not sure what it is, but it looks very interactive

Talk 10 - First hand experiences with the HP detachable - hybrid laptop / tablet (Quentin Wright)

Discounted the surface due to difficulty of typing on your lap, the HP has a nice keyboard that's detachable but appears as a USB device when plugged in.

Had some issues with Win10, despite it being one of the Microsoft Flagship Laptops and purchased from the MS Store. Eventually upgraded to Ubuntu, discovered that KDE was very badly set up for tablet use, but Gnome was very useable.

Talk 11 - Writing a vim plugin (Nick Morrott @nickmorrott)

Nick maintains a database of TV programme descriptions for MythTV users and this database is in a text file (around 7500 lines) with a few different fixed formats.

Whilst this talk was vim-specific, it was more about the general approach to making common tasks easier and could also be applied to emacs (and presumably VS via a plugin).

He referred to the paper "Seven habits of effective text editing" by Bram Moolenaar (the author of vim) which describes a lot of the ideas which drove his development of vim.

Nick went through how to set up a plugin for vim (basically, use one of the many vim plugin managers), and then showed us the code for his syntax highlighter, the code for various utility functions (e.g. create a new type-3 entry) and how to assign them to key-bindings, and finally a syntax checker than automatically highlighted syntax errors as the document was edited.

The syntax checker itself was a perl script, so could also be used as a git pre-commit script with minimal changes, so preventing bad data ever being checked into the repository.

His plugin and associated utilities are here: https://github.com/knowledgejunkie/vim-xmltvfixup

Talk 12 - Introduction to FPGAs (Ralf)

After explaining what the acronym stands for and then explained that in less obtuse terms, I gave a background on the history of why FPGAs are useful, from late 70s/early 80s computer design where glue logic would take up more board space than the CPU and peripherals, to machines like the ZX Spectrum with its ULA (about 100 gates), to PLAs, ASICs and then FPGAs and gave an idea of the scope of what you can do with them.

Showed a slide from my emulation talk, showing a typical cell, and explained what the elements did and then mentioned things like the embedded RAM blocks and hardware multipliers and different kinds of IO ports available.

Ended with the couple of slides showing basic VHDL for adding and multiplying two 16 bit numbers and a snippet of my code showing how bigger chunks of code can look quite high-level.

Finally...

There were probably another 5 topics that we didn't have time to cover and a bunch of want-to-knows that were somewhat covered in smaller BOF groups over lunch, including an introduction to Arduino and how to debug python.

I also proposed 2 more topics myself - "DIY Quadcopters" (which received a lot of votes, but not quite enough to do before we ran out of time) and "What it's like working in the games industry Q&A" (which received only 2 votes).

I had a couple of good conversations about retro computing preservation, Haskell versus Ocaml and quadcopter flight controllers.