When you build real world applications, you are not always on the "happy path". You must deal with validation, logging, network and service errors, and other annoyances.
How do you manage all this within a functional paradigm, when you can't use exceptions, or do early returns, and when you have no stateful data?
This talk will demonstrate a common approach to this challenge, using a fun and easy-to-understand "railway oriented programming" analogy. You'll come away with insight into a powerful technique that handles errors in an elegant way using a simple, self-documenting design.
OpenID Connect is here – and it’s here to stay. This suite of protocols makes federation, single sign-on, session management, discovery and management feasible across arbitrary client types and platforms. It is also a welcome simplification compared to archaic WS*, XML and SAML technologies that made interop often complicated. Dominick walks you through the various bits and pieces – and along the way might even release a new open source project that implements OpenID Connect on the .NET platform ;)
Are you dependent on other people in your job? Do you ever need to get people outside your department on-board to your idea? Do you want to get others in your organization to prioritize your work? Without having the formal authority to do so?
I'll show you techniques and structure you can use to lead people effectively without having formal line authority. And it's all geared towards situations developers might find themselves in!
Apparently, everyone knows about patterns. Except for the ones that don't. Which is basically all the people who've never come across patterns... plus most of the people who have.
Singleton is often treated as a must-know pattern. Patterns are sometimes considered to be the basis of blueprint-driven architecture. Patterns are also seen as something you don't need to know any more because you've got frameworks, libraries and middleware by the download. Or that patterns are something you don't need to know because you're building on UML, legacy code or emergent design. There are all these misconceptions about patterns... and more.
In this talk, let's take an alternative tour of patterns, one that is based on improving the habitability of code, communication, exploration, empiricism, reasoning, incremental development, sharing design and bridging rather than barricading different levels of expertise.
Is it just me, or are we seeing more online attacks leaking more data year by year? Actually it’s not just me because the statistics are there to prove it. In fact the largest online breach we’ve seen to date was less than six months ago when Adobe became the victim of a 152 million record attack. A couple of months later and Target saw 110 million credit cards stolen making it the largest theft of financial data ever. In fact all told, we’re looking at in the order of over 822 million records gone missing in 2013 alone.
The thing is though, when we look back at recent attacks with the clarity of hindsight, they’re almost always easily preventable. Somewhere, somehow, someone had a major oversight in their code – or often many major oversights – that somehow slipped through the cracks, made its way into a production system and was consequently pounced on by someone with malicious intent.
In this session we’re going to look through 10 examples of online attacks that should never have happened. Sometimes it’s a single easily preventable flaws in code, sometimes it’s social engineering of people with access to valuable data and other times it’s a chaining of individual risks knitted together in order to compromise the target. We’re going to systematically work through each of these 10 attacks, understand what went wrong and then assess how each system could have been built to be resilient to the attack.
The lessons learned in this webinar are intended to help you better secure your systems by learning from the mistakes of those who have gone before you.
