Hi,
We (jnthn + masak) 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 masak to give, and 3 proposals for jnthn to give. From here, it depends on how many slots we have; if we were to have 5 slots, then the joint one plus masak's two and the choice of 2 out of the 3 suggested for jnthn 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
Oh no, someone's gone and committed a hand-rolled expression evaluator built entirely of hacks! And someone else built a markup parser out of a hundred regular expressions. Where's the aspirin?
One might think the techniques behind compilers have nothing whatsoever to do with day-to-day enterprise development, but the overlap is significant. As the saying goes, "those who do not understand compilers are doomed to reinvent them... poorly". Add a real power tool to your toolbox: the compiler pattern. With it, you can capture errors in data before they show up in production, and you can rescue code from the unfortunate design decisions of the past. With it, you're the master of your code base, not the other way around.
Presented by Carl Mäsak
You've done everything by the book, following Object-Oriented principles... but your project still grows too complex, and there's scaling problems everywhere. What to do?
Enter aggregates. They're bigger than objects, and they establish a new boundary within which everything is consistent. Learn how to master aggregates, why transactions aren't the answer to everything, and how a little duplication can go a long way.
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.