Rolling Your Own
What's the fastest way to talk to another process? Without pipes or any networking protocol?
Tonight, we're going to build a communications library entirely on shared memory. We'll first discuss the practical motivation, as well as the broader principle of when it's appropriate to roll your own library, and the single most important trick in making such projects viable.
We'll then start coding, and show some practical uses for stuff you might not use every day - including expression trees, pointers, and lock-free synchronization. November 2016.
Future-oriented programming in C#
Just as writing functions doesn't turn you into a functional programmer, writing async methods in C# doesn't turn you into an asynchronous programmer.
To get the full benefit of asynchrony, we must go further and treat futures in the same way that functional programmers treat functions (and object-oriented programmers treat classes).
In this session, we'll go beyond the standard pattern for writing async functions in C#, and demonstrate how to simplify asynchrony and concurrency by thinking of futures as fundamental values. August 2016.
DDD Perth Locknote: Why Pointers Still Matter
As computers continue to become faster, and programming languages more powerful and abstract, the question arises: is there still a need for the humble pointer? I will demonstrate why the answer is 'yes', and show some practical scenarios in C# where some basic pointer skills pave the way for simpler and more efficient applications on today's desktops and devices. August 2015.
YOW West 2015: What's New in C# 6 and the Roslyn Compiler
This session will demonstrate how to use the new features of C# 6 to simplify your code and reduce clutter. We’ll talk about what makes the new “Elvis” operator special, and also demonstrate the power of “Roslyn”, the new compiler-as-a-service. May 2015.
Perth: Debugging a Debugger
If there's one thing harder than writing
a debugger, it's debugging it. Join me for a 45-minute demo on what I learned in writing the integrated debugger for LINQPad, and the lessons in debugging in general. February 2015.
Perth: Tips and Tricks for Asynchronous Programming
Join me for an hour of productivity tips on concurrent and asynchronous programming. We'll cover everything from simple tricks to the monadically marvellous,
and upload extension methods and classes you can take away and use immediately. We'll also describe a general strategy for dealing with difficult concurrency problems,
and discuss which low-level constructs are still relevant, and when to use them. 6 November 2014.
YOW 2013: Solving the Hard Problem of Concurrency
Concurrency is notorious for creating complexity. I argue that the blame lies not with multithreading, mutability, or even shared writable state.
The problem is one of separation: an inability to isolate concurrency logic from application logic. 5 December (Melbourne), 9 December (Brisbane), 12 December (Sydney)
YOW 2013: A Workshop for C# Timelords
Master the time dimension in C# with asynchronous functions and Reactive Extensions.
3 December (Sydney), 4 December (Melbourne), 11 December (Brisbane)
DDD Brisbane 2013: Open Q&A Panel Join me in an open Q&A panel with Scott Hanselman, Hadi Hariri, and Joel Pobar. 7 December 2013
YOW Nights 2013: Programming With Purity
We take for granted that the goto statement is bad. Instead, we employ alternatives that make our code easier to understand and reason over,
namely structured looping constructs such as while-loops and for-loops. But have you ever considered that functional programmers look down on our
looping constructs (or more specifically, our impure use of variables) in the same way we look down on goto? And they've got a point. By avoiding
some of our most time-honoured tricks, we can end up with code that's not only easier to understand and reason over, but that scales better.
October 2013, Brisbane, Sydney, Melbourne.
TechEd 2013: Becoming a C# Time Lord
Join me in a genuine 400-level talk at TechEd 2013 for programmers and architects on how to program time with asynchronous functions and Reactive Extensions.
3-6 September, 2013, Gold Coast.
The Four Laws of Time
You've heard, time and again, that multithreaded programming is impossibly difficult. I'm going to tell you that everything you've heard is wrong:
concurrency itself is reasonably easy. The complexity arises from allowing concurrency logic to mix with application and business logic.
And from confusing time-based concerns with concurrency-based concerns. Solving this properly requires a new way of thinking about time,
concurrency and space. We need to treat time as a dimension in its own right and embrace the Four Laws of Time. Join us as we hop into the
Tardis and take a time-centric look at C#, asynchronous functions and Reactive Extensions. 1 August 2013, Perth.
Keynote, DDD Melbourne: Programming Over Space and Time
Programming evolves through the creation of new abstractions, allowing us to more cleanly express intent while avoiding complexity,
duplication and plumbing code. Yet most of the techniques and patterns in use today assume that the data we need is already there,
spread out over space rather than time. With the rapid growth of interconnected systems, we can no longer afford to treat latency as
an afterthought, creating warts in our otherwise clean designs. Instead, we need to flip our perspective and embrace time as a
first-class concept. In this keynote, we'll make this perspective shift, leading naturally to an understanding of C#'s asynchronous
functions, Reactive Extensions, and the art of programming over both space and time. 20 July, 2013, Melbourne.
Workshop, DDD Melbourne: Hands-on Concurrency Lab
Explore C# 5's asynchronous functions and Reactive Extensions interactively in LINQPad. This is a chance for some hands-on concurrency programming,
as well as an opportunity to discover more about using LINQPad as an exploration and development tool. 20 July, 2013, Melbourne.
Asynchronous Programming in C# 5
Ever struggled writing or debugging multithreaded code? Join Joe Albahari, author of C# 5 in a Nutshell, in Singapore for a practical session
on how to write responsive applications in C# 5 without resorting to threads, locks or BackgroundWorker. We'll explore the theory as well
as the practice behind C# 5's new asynchronous functions, and see why the old-school approach is not only hard work, but fundamentally broken.
We'll also touch on Reactive Framework, and they'll be a question-and-answer session on all aspects of C# 5, asynchrony and multithreading.
4th October 2012, Singapore.
Channel 9 Interview
Join me in a Channel 9 Interview with Charles Torre on LINQPad and C# 5. December 2011, Melbourne.
YOW 2011: Asynchrony in C# 5
With asynchrony the central theme of both C# 5 and Microsoft's upcoming .NET Framework, the question arises, what exactly is asynchrony? And why is it suddenly so important? This session will answer those questions in detail and then take a deep dive with practical examples demonstrating how to put this exciting new technology to work in C# 5.
We'll cover the relationship between asynchrony and multithreading, imperative vs. functional asynchrony (aka Reactive Framework), the importance of hygiene in the thread pool, and most importantly... continuations! You'll see how C# 5's language support for asynchronous continuations makes it as easy as writing one line of code after the other
- and why this is so important in simplifying the development of responsive and performant systems in today's interconnected world.
November, 2011 (Melbourne) + December 2011 (Brisbane)
Hosting in Azure - without the blues
Had enough of your data centre or web hosting company?
Join us at the Perth .NET user group, Thurs Nov 3rd 5:30pm, and find out how to move your MVC or Web Forms apps into the cloud and enjoy
high availability, security and scalability - without the responsibility of OS installation, updates or security. This session will be
full of practical advice and lessons learned from Joe’s own experience migrating two web sites and a licensing server into Azure, all
of which now run inexpensively on a redundant pair of extra small instances.
3rd November, 2011, Perth.
TechEd 2011: Good things come to those who 'await'
Discover the magic of asynchronous programming in C# 5 at TechEd. This is a deep-dive session and will cover both the theory and practice.
September 2, 2011, Gold Coast, Australia.
TechEd 2011: Future of .NET Parallel Programming
Find out about the exciting new technology that's coming to .NET parallel programming - click the link for a recording of this popular session.
September 2, 2011, Gold Coast, Australia.
Good things come to those who 'await'
Experience the magic of C#'s new await and async keywords and how easy asynchronous programming has become with Microsoft's latest CTP. There will be plenty of practical examples, deep dives and discussions on the general principles of asynchronous programming.
June 2, 2011, Perth.
Code Contracts in Framework 4.0
With Framework 4.0, Code Contracts are now a reality. In this session, we'll look first at what Code Contracts are, and then demonstrate how to use them in
Framework 4.0 to write more robust, concise and better-documented code. We'll also look under the covers on how they work, and see how to tailor contract behaviour for development, deployment, legacy and unit testing environments.
May 6, 2010, Perth, Australia
LINQPad as a C# scratchpad
Join me in an interactive webcast on the recent and upcoming features of LINQPad and its support for C# 4.0.
March 23, 2010.
Podcast: On LINQPad, Writing Books and More
In this podcast, Richard Banks talks with Joe Albahari about authoring books, the new dynamic keyword in C# 4.0, how LINQPad evolved,
marketing your own product and finding and getting in touch with your customers.
March 1, 2010
What's new in C# 4.0 - LIDNUG
Take a tour of C# 4.0's new features - in a very practical context. (Almost) no slides and lots of code! This is a free LiveMeeting event open
to all - hosted by LinkedIn Dot Net Users Group and O'Reilly Media. January 26, 2010
What's new in C# 4.0 - Perth
In this talk, I'll cover all of C# 4.0's new features. We'll discuss best practices, show off dynamic Office and Python interop,
and explore some novel uses for dynamic typing that may not have crossed your mind. In particular, we'll examine a surprising pattern
whereby a little quacking can make large classes much more manageable. VB programmers may attend - but please, no smirking!
November 5, 2009, Perth, Australia.
TechEd NZ 2009: How to build a small software enterprise from zero
This is your chance to see the session that I'm presenting at TechEd Australia (Gold Coast) in Auckland.
September 14, 2009, Auckland, New Zealand.
TechEd Australia 2009: How to build a small software enterprise from zero
For years, you've been honing your architecture and programming skills to make someone else rich. Now it's time to turn the tables.
In this one-off talk, I'll cover the lifecycle of writing, selling and maintaining a project on your own, including idea incubation, architecture,
design, marketing, licensing and monetization. There will be numerous practical tips on topics such as getting free advertising, deployment,
maximizing downloads, protecting your IP and handling payments. We'll see how architecture principles differ for Micro-ISVs
and why you'll want to throw many of the best practices that you know and love out of the window.
September 9, 2009, Gold Coast, Australia
.NET Micro-ISV: Get Rich Working From Home
Ever thought of using your .NET skills to write a program to sell over the Internet? It's easier than you think! This presentation will cover both the technical and marketing aspects of what I've learned in setting up a successful Micro-ISV.
June 4, 2009. Perth, Australia.
PLINQ and TPL: Hot New Solutions for Parallel Programming
With Moore's Law forced onto a new path of increased core counts, we must multithread to make our desktop applications run faster.
But there's a problem: the current .NET multithreading APIs are simply not up to the job. Microsoft's upcoming technology preview promises
to address this through two new APIs: the Task Parallel Library and Parallel LINQ. In this session, we'll demonstrate both technologies, and discuss
what it means to think of LINQ queries as functional programming islands. Finally, we'll look at their relative performance, and how well they
transcend the hard problems of thread safety.
October 2, 2008, Perth, Australia
JAOO: LINQ to SQL
Taking the Boredom out of Querying
May 28, 2008 (Sydney) + June 3, 2008 (Brisbane)
JAOO: PLINQ and Parallel Programming
May 28, 2008 (Sydney) + June 3, 2008 (Brisbane)
© 2003-2014 Joseph Albahari