Hi,
Carl and I met to discuss the next event, and came up with some ideas. We came up with one talk that we'd give jointly, 2 proposals for Carl to give, and 3 proposals for me to give. From here, it depends on how many slots we have; if we were to have 5 slots, then the joint one plus Carl's two and the choice of 2 out of the 3 I suggested would work. If we are going to have a guy come along and do a couple of JavaScript ones, that'd take us up to 7 sessions, which is enough for an event. :-)
Anyway, here's the ideas.
Presented jointly by Carl Mäsak and Jonathan Worthington
The Git version control system is becoming increasingly popular. Many open source projects have embraced it, and an increasingly number of closed sourced projects are also doing so. So what's the hype about? And does Git make your development more or less complex?
In this talk, two experienced Git users will demonstrate how it works, and walk you through various development workflows that Git makes easy. From simple things like feature branches through to more involved distributed scenarioes, such as moving versions of code from development, through testing and into production, we'll show you how it looks and explain how it helps.
Presented by Carl Mäsak
Those scary folks working on compilers wouldn't know much about solving business problems, right? Wrong! It turns out that the very skills used to transform high level language code into low-level code show up as being useful again and again in business scenarios. In this talk, I'll look at these techniques and look at how they have been applied in a range of real-world situations to effectively solve problems.
Presented by Carl Mäsak
Object orientation helps us put explicit boundaries in our code, through encapsulation. However, the build large systems, that's not enough. We need larger bounded units in order to keep things manageable. Then there's the question of how we model: what should we be creating classes to represent, exactly? Aggregates offer us some answers to both of these, leading us to better factored code.
Presented by Jonathan Worthington
Codepoints! Graphemes! Surrogate pairs! Combining characters! Normalization forms! And you thought strings were a simple data structure.
It turns out that representing all of the world's languages digitally is hard. Unicode, as a result, is also packed full of complexity. In this talk, we'll look at why it's such a hard problem, and unpack how Unicode works. We'll discuss the difference between characters and encodings and how to keep things sane. You'll come out knowing a bunch of things you always wanted to about text - and probably a bunch you really didn't want to know too.
Presented by Jonathan Worthington
What's the difference between task and data parallelism? What types of lock should you use, and when? How do concurrent collections fit in? How do you build lock-free data structures? In this talk, we'll compare various approaches to parallelism and see how each of them can be useful.
Presented by Jonathan Worthington
From classics like SQL injection and XSS, through to the Web 2.0-conformant crappily secured Ajax, along with the rather more subtle CSRF, there's decidedly more than one way to screw it up. In this session, we'll consider a bunch of them, and see how to protect yourself.