Sign In
Fabulous Adventures In Coding
Eric Lippert's Blog
Tags
Aargh! (8)
accuracy (6)
Arrays (8)
ASP (11)
AStar (5)
Async (15)
bad jokes (14)
Begging the question (4)
Benford's Law (3)
Best Of FAIC (12)
Big Words (5)
Books (23)
Breaking Changes (24)
Brittle Base Classes (6)
C# (326)
C# 4.0 (39)
C# 5.0 (10)
Cargo Cult Programming (4)
cast operator (3)
Channel 9 (6)
Charts (6)
closures (3)
Code Generation (10)
Code Quality (29)
COM Programming (57)
Conditional Operator (3)
Continuation Passing Style (11)
Conversions (16)
Covariance and Contravariance (22)
customer service (4)
declaration spaces (5)
definite assignment (3)
Dialogue (14)
English Usage (11)
exception handling (9)
Floating Point Arithmetic (15)
grammars (9)
graph colouring (5)
GUIDs (3)
Hashing (9)
High Dimensional Spaces (5)
Immutability (27)
integer arithmetic (5)
Interviewing (8)
Introduction (6)
It Hurts When I Do This (5)
Iterators (10)
JScript (93)
JScript .NET (29)
keywords (4)
Lambda Expressions (20)
Language Design (62)
local variables (3)
localization (3)
Mathematics (18)
Memory Management (13)
Metablogging (9)
Mistakes (6)
Music (6)
myths (7)
namespaces (5)
Non-computer (37)
Optional arguments (5)
Overload Resolution (9)
Pages (25)
Performance (48)
precedence (4)
precision (7)
protected (7)
Puzzles (49)
quotable quotations (4)
Rants (51)
Rarefied Heights (52)
reachability (4)
Recursion (26)
reference (4)
Regular Expressions (13)
Relationships (4)
Salt (4)
Science (12)
scope (5)
Scripting (189)
Security (46)
shadowcasting (6)
SimpleScript (30)
Software development methodology (13)
Static Methods (6)
Threading (18)
Topological Sort (4)
Type Inference (18)
type safety (4)
unsafe code (4)
Value Types (11)
VBScript (80)
Video (12)
virtual dispatch (9)
VSTO (10)
warnings (5)
What's The Difference? (11)
Zombies (4)
Browse by Tags
MSDN Blogs
>
Fabulous Adventures In Coding
>
All Tags
>
async
Tagged Content List
Blog Post:
Async articles
Eric Lippert
I am pleased to announce that MSDN Magazine is doing a special issue this month on the new "async-await" feature that we are working on for the next versions of C# and Visual Basic. If this subject interests you, see my introductory article for beginners , Mads Torgersen's article on how it works behind...
on
3 Oct 2011
Blog Post:
Refreshing the Async CTP
Eric Lippert
Good morning everyone! I am pleased to tell you that the C# and VB teams are announcing a "refresh" of the async Community Technology Preview at MIX11 today, and that it is as of right now available on the Async CTP site . Recall that the CTP release is an early look at our thinking for the proposed...
on
13 Apr 2011
Blog Post:
Asynchrony in C# 5, Part Eight: More Exceptions
Eric Lippert
(In this post I'll be talking about exogenous , vexing , boneheaded and fatal exceptions. See this post for a definition of those terms .) If your process experiences an unhandled exception then clearly something bad and unanticipated has happened. If its a fatal exception then you're already in no position...
on
23 Nov 2010
Blog Post:
Asynchrony in C# 5, Part Seven: Exceptions
Eric Lippert
Resuming where we left off (ha ha ha!) after that brief interruption: exception handling in "resumable" methods like our coroutine-like asynchronous methods is more than a little bit weird. To get a sense of how weird it is, you might want to first refresh your memory of my recent series on the design...
on
19 Nov 2010
Blog Post:
Asynchrony in C# 5 Part Six: Whither async?
Eric Lippert
A number of people have asked me what motivates the design decision to require any method that contains an "await" expression to be prefixed with the contextual keyword "async". Like any design decision there are pros and cons here that have to be evaluated in the context of many different competing...
on
11 Nov 2010
Blog Post:
Asynchrony in C# 5 Part Five: Too many tasks
Eric Lippert
Suppose a city has a whole bunch of bank branches, each of which has a whole bunch of tellers and one gofer. There are a whole bunch of customers in the city, each of whom wants to withdraw a whole bunch of money from the bank at some varying time throughout the day. The algorithm goes like this: A customer...
on
8 Nov 2010
Blog Post:
Asynchrony in C# 5.0 part Four: It's not magic
Eric Lippert
Today I want to talk about asynchrony that does not involve any multithreading whatsoever. People keep on asking me "but how is it possible to have asynchrony without multithreading?" A strange question to ask because you probably already know the answer. Let me turn the question around: how is it possible...
on
4 Nov 2010
Blog Post:
Asynchrony in C# 5, Part Three: Composition
Eric Lippert
I was walking to my bus the other morning at about 6:45 AM. Just as I was about to turn onto 45th street, a young man, shirtless, covered in blood ran down 45th at considerable speed right in front of me. Behind him was another fellow, wielding a baseball bat. My initial thought was "holy goodness, I...
on
1 Nov 2010
Blog Post:
Asynchronous Programming in C# 5.0 part two: Whence await?
Eric Lippert
I want to start by being absolutely positively clear about two things, because our usability research has shown this to be confusing. Remember our little program from last time? async void ArchiveDocuments(List<Url> urls) { Task archive = null; for(int i = 0; i < urls.Count; ++i) { var document...
on
29 Oct 2010
Blog Post:
Asynchrony in C# 5, Part One
Eric Lippert
The designers of C# 2.0 realized that writing iterator logic was painful. So they added iterator blocks. That way the compiler could figure out how to build a state machine that could store the continuation - the “what comes next” - in state somewhere, hidden behind the scenes, so that you don’t have...
on
28 Oct 2010
Blog Post:
Continuation Passing Style Revisited Part Five: CPS and Asynchrony
Eric Lippert
Today is when things are going to get really long and confusing. But we'll make it through somehow. Consider the following task: you’ve got a list of URLs. You want to fetch the document associated with each URL. (Let’s suppose for the sake of argument that this always succeeds.) You then want to make...
on
27 Oct 2010
Blog Post:
Continuation Passing Style Revisited Part Four: Turning yourself inside out
Eric Lippert
The obvious question at this point is: if CPS is so awesome then why don’t we use it all the time? Why have most professional developers never heard of it, or, those who have, think of it as something only those crazy Scheme programmers do? First of all, it is simply hard for most people who are used...
on
26 Oct 2010
Blog Post:
Continuation Passing Style Revisited Part Three: Musings about coroutines
Eric Lippert
Last time I sketched briefly how one might implement interesting control flows like try-catch using continuations; as we saw, the actual implementations of Try and Throw are trivial once you have CPS. I'm sure that you could extend that work to implement try-catch-finally. Or, another basic exercise...
on
25 Oct 2010
Blog Post:
Continuation Passing Style Revisited Part Two: Handwaving about control flow
Eric Lippert
Last time on Fabulous Adventures: “ But we can construct arbitrarily complex control flows by keeping track of multiple continuations and deciding which one gets to go next. ” Let’s look at an example of something more complex than a conditional. Consider a simplified version of “try-catch”, where there...
on
22 Oct 2010
Blog Post:
Continuation Passing Style Revisited, Part One
Eric Lippert
Good morning fabulous readers, let me just start by saying that this is going to get really long and really complicated but it will all pay off in the end. I’m also going to be posting on an accelerated schedule, more than my usual two posts per week. (It’ll eventually become clear why I'm doing all...
on
21 Oct 2010
Page 1 of 1 (15 items)