Mollybrake3's blog

Fancy Dress Ideas Ideas For Young People - Give Funny Take A Look At Kids

Red is undoubtedly a perfect option for outfits among those birdes-to-be who are looking for modern and manner. This dress is definitely evening or cocktail dress which happens to be quite short. However, if you employ a basic understanding for these two elements My partner and i mentioned, it will provide help to choose a more desirable dress with self-confidence. The most favorite and publicized trend is just as before metallic colors. Based on the form of your body you must tailor made the dress in order that it fits your entire body well. To them in case women dress independently in modest clothes, ensures that typically the feminine side within the woman is conserved.

Wholesale Pronovias bridal gowns offers the same vast array of features and kinds as retail businesses. There are endless possibilities in terms of cocktail dresses. Remember, you aren't jogging down the aisle at this time. These winter dresses is usually manufactured with in depth range clothing mannequin of fabric as well as fur, leather, wool etc. For example: bridesmaid dresses, wholesale prom suits, party dresses, evening dresses, mother of your bride dress, cocktail dresses, formal wear. Coco Chanel changed everything that by creating a basic black dress. If you dont aspire to look like a new flower girl within prom night, these dresses short-term for you.

Technically, a dress over 19 years old is classed as as 'vintage; ' any older than 100 years and it becomes 'antique. ' The 20th century saw an ever-changing succession of fashions, providing us with a great many alluring vintage dresses to choose from. Back in the day, self-esteem and shape image issues were compounded because of the sheer lack with plus-size prom clothes and formal eveningwear. Purchasing a heavy dress it does not breathe will just about guarantee you'll be dead on your own feet before the very last dance. You can have a designer dress exclusively designer with a well-known designer and use it to attain exclusive looks at a party. For added intricacy, you'll love this empire waist which comes accentuated which has a crisp grosgrain wedding ring that flows towards a full tulle cover.



Your a lot of prominent wedding guest will see herself with lots to do on her behalf daughter's wedding working day and comfort is sometimes key. No longer must bridesmaids select from the hideous heated pink or babe blue chiffon costume that absolutely screams wedding party. Remember, the threads and seams of the dresses may not really withstand the turmoil within the washing machine so you'll want to wash them with all your hands. The faster the location dries, the less likely it really is to leave the water mark regarding white dresses. In the past lots of the halter dresses had only one tie closure having two thick bits of material you were directed at tie in any knot to obtain your dress. And there is not any point in picking a wonderful party dress without deciding on the best shoes. This dress is supplied in ivory/champagne, solid ivory and timeless solid bright white.

Talking about customized gowns, many girls may consider expensive or superb dresses which price tag an arm along with a leg. Women have a lot of options or styles for winter dresses. Before the 1920s, black was mostly employed for mourning and most women wore layers together with layers of components. Remember, finding the perfect mother within the bride dress for the most prominent wedding guest could prove a terrific bonding experience together with your mother. Its strapless cut is wonderful for highlighting delicate collarbones, long necks in addition to elegant jaw wrinkles. The style that suits yourself type, the occasion, the look which you need to sport, such factors should enable you to decide which dress you need to wear to that place. The taste of your bride plays a major hand to control the buying choice.

Shielding Your Trampoline Coming From Severe Weather

For folks that choose to n't have a trampoline box then, by having the actual trampoline mat within ground degree, the risk involving accident from falling off of the trampoline is lower. And most of the accidents were sustained by people at age 14 or newer. Whether they choose a standard size trampoline or perhaps children's trampoline people definitely need grown-up supervision. Replacing the mat having a new one might most likely make the trampoline sound new mini trampoline rebounder repeatedly. Falling off typically the trampoline also may bring about head trauma, paralysis, bone fractures and also dislocations, and ultimately, as said early on, death.



Do some Tuck Jump, Straddle Jump as well as Pike Jump one when the other, take a few bounces to recoup and repeat have a look at times. You can purchase them used if you rave about but it is more preferable to find bargains on new springs as an alternative to used. Most of folks how purchases trampolines wish smoothing but to better of it, perform ridiculous stop, all for that sake of a quality and clean entertaining. The stabilizing bar tends to get in how when just moving. If you're visiting buy a trampoline, follow these strategies of safety and fun into it.

JumpKing Trampolines offer the various latest advances with trampoline design at very reasonably priced prices. Safety nets fit within the trampoline and avoid falls onto the earth. You will really need to leave a difference of perhaps inches to the trampoline for this function. The material what is the right users can bounce is usually known as your trampoline bed. Earlier to taking your trampoline however one should develop to become conscious of how much of important all spherical performance indicators contrary to getting disappointed after bringing it household.

Many trampoline single point kits will differ on their setup, but here is really a general idea for list of positive actions while installing any trampoline anchor product. But if that you're extra serious in relation to kayaking, you will have the ability to find a better kayak to meet your requirements. If there isn't soft ground across the trampoline it is usually painful to acquire. All people who join the experience need to keep away from becoming hit simply by any ball. That way you'll be able to take pleasure on a safe and remarkable trampoline jumping months. If your trampoline was produced by JumpKing, Hedstrom, or JumpSport, it should be very simple to find an appropriate housing.

Another option available may be to purchase an houseplants bouncer or rebounder. It is a large purchase, and one which needs to be considered carefully. The galvanized comes recommend you utmost support and even great quality. To measure the mat you have got to measure the pad itself, end to close, not including the particular v-rings. You should also look into the warranties for that pads and sparring floor. They are best for both kids and also adults allowing similar tummy tickle available as was when a child. Where ever with all the welded joints your cracked joint will have to have the replacement of your entire frame article.

8 Techniques Of An Online Payday Loan Collector

Most in todays population is one of the working class and that they usually get their own pay only each. There are lots of people who opt to roll in the original loan amount month for month and merely give the finance premiums. Banks do not permit you to lend small amounts but you cannot find any such limitation with cash advance loans. You need for you to submit a authorized post-dated cheque to be replaced by the lender which may pose as a security with loan.

You work hard to give better amenities in your family. The loans are available online to this salaried residents. However, you will will need to give the lender whether post-dated check for how much the loan together with interest charges and also an authorization designed for electronic checking withdrawal of their amount. You might have witnessed quite many advertisements suggesting "Get Quick Cash" or maybe "Get a Salaryday Loan" or "Short at Cash". You may payday cash advance loans find and buy numerous providers both online or personally who would readily enable you to with your fiscal crises. When all the prerequisites are accomplished, approval of the loan may be within twenty-four numerous hours or less when submission.

On your cash advance application you must include around two, sometimes three clients and lenders prefer you make use of immediate family individuals. Payday loan is a sort of short term mortgage loan vehicle that helps you to borrow a bit of money you really need to survive until the subsequent paycheck. Therefore, you have so that you can compare those interest rates of different financial loan lending companies and so, that you will be able to Instant Fax Less Payday advances at suitable apr. Cash Till Payday cash loans is short-term loan that is certainly why the rates for Cash Till Payday cash advances are higher than the interest for long period loans. No teletrack pay day loans are loaded with cash for folks who suffer from bad credit history or also have recently filed regarding bankruptcy, offering a quick approach of obtaining cash that can cover a great emergency financing issue.



Any a person that is accustomed to live a life a life as a result of paycheck to paycheck knows perfectly how difficult it becomes to prepare additional funds for the emergency between a couple pay dates. There is simply no need of faxing any documents while you apply. Neither do you should wait in long queues in order to satisfy the competent authority getting an approval. Cash advance loans might be paid back with the next payday. They find bankruptcy being the only solution that will overcome and meet their pay day loan debts.

There vary reasons why some individuals prefer not to use a.teletrack look at their loan heritage, but most banking institutions see this like a sign that this borrower has certain troubles along with credit. Usually when individuals are going for borrowing products, they often normally forget about many conditions that require attention. Too many financial loans, when figured from your monthly net gain, can be a large point against a person's approval. When this situation happens you may choose to really find difficult to find rid the importance completely. The amount of loan and also interest charges are generally deducted from your money and transferred in to the lending corporation.

The applicability for faxless bad credit online payday loan is huge. It is helpful financial technique to meet your midst month cash crisis straightaway. In these situation managing quick cash to spend to mechanic as soon as your car breaks down is usually a daunting task. Other things to check on when visiting an internet site include testimonials from other those who have patronized their services additionally, the "about us" component to the company, to familiarize yourself with all the company's history, record and the place the company connected to. Remember that you're on a binding contract in your creditor once your own loan gets permitted. For many, a no fax online payday loan represents a easy and paperless usage of funds that are immediately needed to meet an crisis need.

Following the pattern

Here's a question I got from a user recently:

The foreach loop in C# uses a pattern-based approach to semantic analysis. LINQ in C# also uses a pattern-based approach. Why don't other features, such as the "using" statement, also use a pattern-based approach?

What a great question!

First off, what do we mean by a "pattern-based approach"?

You might think that in order to use a foreach loop, the collection you are iterating over must implement IEnumerable or IEnumerable<T>. But as it turns out, that is not actually a requirement. What is required is that the type of the collection must have a public method called GetEnumerator, and that must return some type that has a public property getter called Current and a public method MoveNext that returns a bool. If the compiler can determine that all of those requirements are met then the code is generated to use those methods. Only if those requirements are not met do we check to see if the object implements IEnumerable or IEnumerable<T>.

Essentially, C# is doing a fairly strong form of "duck typing" here. That is, if the object is known at compile time to have a Quack() method then we treat it like a duck even if it isn't marked as implementing IDuck. There are a few places in the C# language where we do this sort of "pattern matching"; we don't care what the exact type is, just so long as the methods we need are available.

But why do we use a pattern-based approach in foreach in the first place?

Two reasons. First, imagine a world without generic types: the world of C# 1.0. Suppose you have a collection that you yourself have just implemented, a collection of ten square integers:

class MyIntegers : IEnumerable
{
  private class MyEnumerator : IEnumerator
  {
    private int index = 0;
    public object Current { return index * index; }
    public bool MoveNext()
    {
      if (index > 10) return false;
      ++index;
      return true;
    }
  }
  public IEnumerator GetEnumerator() { return new MyEnumerator(); }
}

When you "foreach" over this thing, every integer that comes out of the collection is boxed. How can you avoid the boxing penalty? Like this:

class MyIntegers : IEnumerable
{
  public class MyEnumerator : IEnumerator
  {
    private int index = 0;
    object IEnumerator.Current { return this.Current; }
    int Current { return index * index; }
    public bool MoveNext()
    {
      if (index > 10) return false;
      ++index;
      return true;
    }
  }
  public MyEnumerator GetEnumerator() { return new MyEnumerator(); }
  IEnumerator IEnumerable.GetEnumerator() { return this.GetEnumerator(); }
}

Now the foreach loop sees can use the public method GetEnumerator that returns a MyEnumerator, that in turn has a public property Current that returns an int. No boxing required.

The second reason is because using this approach, the "MyEnumerator" could also be a mutable struct. Yes, mutable structs are a bad programming practice, but in this case it's not so bad because the "foreach" loop is never going to expose the raw enumerator to possible misuse by user code. Sometimes you really do want to avoid collection pressure, so making the enumerator a struct can be a small but measurable win. (As always, do not make things into structs "because they are faster" unless you have empirical evidence that doing so makes a measurable and important difference.)

So there you go: we use a pattern-based approach for "foreach" because first, we didn't have the ability to avoid boxing via IEnumerable<T> in C# 1.0, and because there is a small but perhaps important performance win in avoiding the pressure of allocating a reference-typed enumerator.

What about LINQ? We also use a pattern-based approach in LINQ. When you say "from c in customers where ..." we do not require that "customers" have a "Where" method, or even that it implement IEnumerable. We don't have any type requirements on it at all; rather, we require that overload resolution finds an instance method or an extension method called "Where" that works with the LINQ pattern.

Again, two reasons. The first reason is that LINQ was invented very late; it would not be a success if we required everyone who wanted to have their data source work with LINQ have to ship a new version of their interface that has Where and Select methods. It has to be a feature that "lights up" without any work on behalf of the data source providers.

The second and more highfalutin reason is that LINQ was designed to bake the "monad" pattern into C#. It was specifically designed to bake in the "sequence" monad, but if you are a crazy person you can actually use query comprehension syntax to represent binding operations on any monad, as Wes points out in his excellent article. People sometimes ask why there is no "IMonad" interface in C# that identifies a type that can be used as a monad. The short answer is that the concept of "I am a type that obeys the rules of a monad" is actually too general for the .NET type system to handle; the monad pattern is a "higher type" than an interface. Therefore, rather than bake it into the type system, we baked it into the compiler. (*)

So now we come to the user's actual question: given that we use this pattern-based approach in several places in C#, why not use it everywhere? Why require that an object implement IDisposable to be disposed in a "using" block? Why not just require that it implement a public method called Dispose?

The answer is that we like capturing things in type systems; we do so whenever we can. Types are our first and best solution for solving problems in a statically-analyzed language, and so we want to stick to that whenever possible. In the case of the "using" block there is no compelling reason to not require that a disposable object mark itself with a special interface. We've already seen that we can elide boxing in things that get disposed, and even if we cannot, the boxing penalty is pretty small for disposing a dozen handle-holding objects compared to the penalty of boxing a million integers coming out of a collection. And the LINQ reasoning doesn't apply to "using" -- we do not want you to be able to extend the disposal behaviour of objects you do not own, even as we do want you to be able to extend the sorting, searching and grouping behaviours of objects you do not own. With no compelling reason for a pattern-based approach, and no compelling reason against an interface-based approach, we went with the interface.

However, as the C# language gets more and more high-level features added to it, we are finding that often a pattern-based approach is necessary. The coming "async/await" feature, for example, will use a LINQ-like pattern-based approach to figuring out how to make an "awaiter" for a particular "task" object. Pattern-based approaches can allow more participation by third parties and enable language designers to embed design patterns in the language that are too rich for their type systems to handle, so I would expect to see more of this sort of thing in the future.

--------------------

(*) A detailed explanation of why the .NET type system is insufficient to represent higher types would take us pretty far afield. If this subject interests you, see this StackOverflow question. For more ideas on how the generic type system of .NET is insufficient to represent certain desired patterns, see my recent article on the subject. If you want an even more gentle introduction to monads than Wes's article, see this StackOverflow question.

Source: http://blogs.msdn.com/b/ericlippert/archive/2011/06/30/following-the-pattern.aspx

TRIDENT MICROSYSTEMS TRANSACTION SYSTEMS ARCHITECTS TOTAL SYSTEM SERVICES

Building a PC, Part VII: Rebooting

I've had more or less the same PC, with various updates, since 2007. I've written about most of it here:

• Building a PC, Part I: Minimal boot
• Building a PC, Part II: Burn in
• Building a PC, Part III: Overclocking
• Building a PC, Part IV: Now It's Your Turn
• Building a PC, Part V: Upgrading
• Building a PC, Part VI: Rebuilding

While the advice in those original articles is still quite sound, my old 2007 era case was feeling mighty creaky. I needed a new chassis. I also wanted a motherboard that supported native 6 Gbps SATA for the latest generation of SSDs that truly benefit from them. The buzz around the Sandy Bridge based Core i7-2600k was nearly deafening, and I've fallen completely in love with my last HTPC build based on the same technology. (Oh, and even if you already read that article, read it again because I added new PicoPSU and case information that takes it from awesome to sublime – on the order of 17 watts idle!)

So I decided it was time to build myself a nice Sandy Bridge system. What I ended up with is easily the best case and motherboard combination I've ever laid hands on. Read on!

I cut out a lot of the initial research work by relying on my old, dear friends at Tech Report and their current workstation recommendations:

• Asus P8Z68-V Pro $220
• Corsair Vengeance 16 GB kit $155
• Core i7-2600K $315

As for the case, I was impressed by the Tech Report review of the Corsair 600T, which even comes in a heart-stopping pseudo stormtrooper white. WANT.

When it comes to power supplies, I'm crazy about efficiency, and fortunately there are now lots of so-called "80 Plus Gold" PSUs out there now, offering a staggering 90% efficiency under most loads. Power supply efficiency is important, because the rest of that heat is dumped back into your case. The less efficient your PSU, the more heat buildup you'll have under load. I chose the Seasonic X-760 – which, when bench tested, indeed delivered the promised 90% efficiency – but any high quality 80 Plus Gold model will generally do.

The CPU (and possibly, depending on your tastes, the video card) is the biggest heat generator inside your PC. The better and more efficient the CPU cooler, the quieter your whole system can be. This also affects how much you can overclock. I chose the Thermalright Venomous-X Silent Edition on the basis of it being the current top dog for efficiency, and because it had a simple mounting system. Large coolers can be a real bear to install. And did I mention it comes with an especially quiet fan out of the box, too?

Once I had all the parts in hand, it was a simple matter of building it up, as documented in my previous post series. I adore this Corsair case; it is an absolute joy to work in. Everything in it is cleverly designed, from the rear cable routing area with rubber grommets all over the place for easily passing cables back and forth, to the tool-less 2.5" and 3.5" bays, to the super easily removable side panels. It's like they read a giant list of all my prior complaints with every PC case I've ever used and fixed every. single. last. one of them.

The end result is what you see here:

There are some significant tweaks visible in the above picture that I do recommend:

1. Use tin snips to remove the rear exhaust grill. We don't need it back there, and the exhaust airflow is critical. Fan grills affect low-speed fan airflow more than you'd think:

   Wire grills also have an effect: ~20%. This was checked with an anemometer on several different fans of 80, 92 and 120mm size, at full and lower speeds. The airflow reduction went as high as 24% but it was never below 19%. At 12V, the reduction in airflow with most fans will be relatively harmless, though there is an increase in turbulence noise (audible to me). But at the low airflow rates SPCR members run fans, I think the airflow reduction is significant.

2. Install a 140mm rear exhaust fan. The Noctua NF-P14 is expensive at $25 but is cleverly designed to give you 140mm of super-quiet fan in the space a 120mm fan would normally take. It just barely fits in the rear exhaust fan slot with a little nudging. But it does fit; it's the beige fan in the above picture. It also comes with its own speed reducers and accessories.
   
   
3. Use fan speed reducers on all the fans. The case has two 200mm fans, and the 140mm fan we're adding. I couldn't get the Asus motherboard's "QFan" fan control system to work, as it seems to require 4-pin fans, and all the ones I had (including the ones that came with the case) are 3-pin. While I do prefer dynamic, temperature based control when I can get it, the next best thing is to use hardware to slow down the fans. I like the Zalman-ZM-RC56 resistor connector as the simplest solution, but it's getting hard to find for some reason. The Zalman Fan Mate 2 will also work, and allows you to individually adjust the speed of each fan. The case also has a built in fan controller – that's the knob you see on the front top – but I found it too limited in range for my purposes.
   
   
4. Add acoustic foam to taste. Between inexpensive eggcrate foam and thin, adhesive backed open-cell foam, you can easily reduce that last 10-20% of fan noise to a very pleasant white noise. It works well in the areas pictured, and also on the interior of the side panel "facing" the fans. See item 6 in my Building a Quiet PC post for details.

And then, of course, the overclockening. What kind of geek would I be if I didn't attempt to turn this baby up to 11? This is another area where Sandy Bridge is a revelation: so long as you buy one of the blessed "K" series processors, overclocking is as simple as setting the multiplier to the desired value. It is ridiculously simple. And my results, for once, were immediately as good as the ones everyone else was crowing about: 4.4 GHz totally stable!

(beware: there is one nasty little issue with the Asus motherboard's auto-overclock feature. The PLL Overvoltage setting, which auto-overclock "helpfully" enables, completely bollixes up resuming from sleep. Just turn it off, and all is well. I don't even want to tell you how long it took me to figure that one out.)

The total package with a nice SSD delivers a near-perfect Windows Experience score:

I won't lie to you. This is not a compact build. It's big! Those roomy side areas come at a cost, and that makes it a very wide case. But that's to be expected for a desktop powerhouse machine. And since my last case lasted me from 2007-2011, I'll happily accept a little bulk for something that's easy to work on and upgrade over time.

It's a fantastic new reboot of my system, and I didn't expect to be this excited about the final result. This is not merely an incremental improvement over what I had, it's much quieter, easier to work on, and when overclocked to 4.4 GHz, noticeably faster too. (I do slightly mourn the loss of 8 GB of RAM, but I'll survive.)

In this build, I already had hard drives, DVD drive, a sound card, and so forth … but for completeness' sake I'll list everything here if you want to mirror this setup. Realize that some of this comes down to personal taste, so I'm just listing what I recommend. Feel free to change anything out, and bear in mind that Sandy Bridge has decent default onboard video as well.

• Asus P8Z68-V Pro $220
• Corsair Vengeance 16 GB RAM $155
• Core i7-2600K CPU $315
• Corsair 600T Special Edition case $170
• Corsair 850w 80 Plus Gold PSU $170
• Thermalright Venomous-X Silent Edition CPU heatsink $75
• Vertex 3 240 GB SSD $500
• WD Caviar Green 3 TB HDD $170
• Noctua Ultra Silent 140mm Fan NF-P14 FLX $25
• Radeon 6850 triple monitor capable video card $170

Remember, if you can put together a LEGO kit, you can build this totally sweet PC for yourself, too. Good luck and happy building!

Source: http://www.codinghorror.com/blog/2011/07/building-a-pc-part-vii-rebooting.html

WESTERN DIGITAL VOLT INFORMATION SCIENCES VISHAY INTERTECHNOLOGY

Eduasync part 12: Observing all exceptions

(This post covers projects 16 and 17 in the source code.)

Last time we looked at unwrapping an AggregateException when we await a result. While there are potentially other interesting things we could look at with respect to exceptions (particularly around cancellation) I'm just going to touch on one extra twist that the async CTP implements before I move on to some weird ways of using async.

TPL and unobserved exceptions

The Task Parallel Library (TPL) on which the async support is based has some interesting behaviour around exceptions. Just as it?s entirely possible for more than one thing to go wrong with a particular task, it's also quite easy to miss some errors, if you're not careful.

Here's a simple example of an async method in C# 5 where we create two tasks, both of which will throw exceptions:

private static async Task<int> CauseTwoFailures()
{
    Task<int> firstTask = Task<int>.Factory.StartNew(() => {
        throw new InvalidOperationException();
    });
    Task<int> secondTask = Task<int>.Factory.StartNew(() => {
        throw new InvalidOperationException();
    });

    int firstValue = await firstTask;
    int secondValue = await secondTask;

    return firstValue + secondValue;
}

Now the timing of the two tasks is actually irrelevant here. The first task will always throw an exception, which means we're never going to await the second task. That means there's never any code which asks for the second task's result, or adds a continuation to it. It's alone and unloved in a cruel world, with no-one to observe the exception it throws.

If we call this method from the Eduasync code we've got at the moment, and wait for long enough (I've got a call to GC.WaitForPendingFinalizers in the same code) the program will abort, with this error:

Unhandled Exception: System.AggregateException: A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread. ---> System.InvalidOperationException: Operation is not valid due to the current state of the object.

Ouch. The TPL takes a hard line on unobserved exceptions. They indicate failures (presumably) which you'll never find out about until you start caring about the result of a task. Basically there are various ways of "observing" a task's failure, whether by performing some act which causes it to be thrown (usually as part of an AggregateException) or just asking for the exception for a task which is known to be faulted. An unobserved exception will throw an InvalidOperationException in its finalizer, usually causing the process to exit.

That works well in "normal" TPL code, where you're explicitly managing tasks - but it's not so handy in async, where perfectly reasonable looking code which starts a few tasks and then awaits them one at a time (possibly doing some processing in between) might hide an unobserved exception.

Observing all exceptions

Fortunately TPL provides a way of us to get out of the normal task behaviour. There's an event TaskScheduler.UnobservedTaskException which is fired by the finalizer before it goes bang. The handlers of the event are allowed to observe the exception using UnobservedTaskExceptionEventArgs.SetObserved and can also check whether it's already been observed.

So all we have to do is add a handler for the event and our program doesn't crash any more:

TaskScheduler.UnobservedTaskException += (sender, e) =>
{
    Console.WriteLine("Saving the day! This exception would have been unobserved: {0}",
                      e.Exception);
    e.SetObserved();
};

In Eduasync this is currently only performed explicitly, in project 17. In the async CTP something like this is performed as part of the type initializer for AsyncTaskMethodBuilder<T>, which you can unfortunately tell because that type initializer crashes when running under medium trust. (That issue will be fixed before the final release.)

Global changes

This approach has a very significant effect: it changes the global behaviour of the system. If you have a system which uses the TPL and you want the existing .NET 4 behaviour of the process terminating when you have unobserved exceptions, you basically can't use async at all - and if you use any code which does, you'll see the more permissive behaviour.

You could potentially add your own event handler which aborted the application forcibly, but that's not terribly nice either. You should quite possibly add a handler to at least log these exceptions, so you can find out what's been going wrong that you haven't noticed.

Of course, this only affects unobserved exceptions - anything you're already observing will not be affected. Still, it's a pretty big change. I wouldn't be surprised if this aspect of the behaviour of async in C# 5 changed before release; it feels to me like it isn't quite right yet. Admittedly I'm not sure how I would suggest changing it, but effectively reversing the existing behaviour goes against Microsoft's past behaviour when it comes to backwards compatibility. Watch this space.

Conclusion

It's worth pondering this whole issue yourself (and the one from last time), and making your feelings known to the team. I think it's symptomatic of a wider problem in software engineering: we're not really very good at handling errors. Java's approach of checked exceptions didn't turn out too well in my view, but the "anything goes" approach of C# has problems too... and introducing alternative models like the one in TPL makes things even more complicated. I don't have any smart answers here - just that it's something I'd like wiser people than myself to think about further.

Next, we're going to move a bit further away from the "normal" ways of using async, into the realm of coroutines. This series is going to get increasingly obscure and silly, all in the name of really getting a feeling for the underlying execution model of async, before it possibly returns to more sensible topics such as task composition.

Source: http://feedproxy.google.com/~r/JonSkeetCodingBlog/~3/zyybvIYgbfM/eduasync-part-12-observing-all-exceptions.aspx

YAHOO XILINX WESTERN DIGITAL

Eduasync part 17: unit testing

In the last post I showed a method to implement "majority voting" for tasks, allowing a result to become available as soon as possible. At the end, I mentioned that I was reasonably confident that it worked because of the unit tests... but I didn't show the tests themselves. I felt they deserved their own post, as there's a bigger point here: it's possible to unit test async code. At least sometimes.

Testing code involving asynchrony is generally a pain. Introducing the exact order of events that you want is awkward, as is managing the threading within tests. With a few benefits with async methods:

• We know that the async method itself will only execute in a single thread at a time
• We can control the thread in which the async method will execute, if it doesn't configure its awaits explicitly
• Assuming the async method returns Task or Task<T>, we can check whether or not it's finished
• Between Task<T> and TaskCompletionSource<T>, we have a way of injecting tasks that we understand

Now in our sample method we have the benefit of passing in the tasks that will be awaited - but assuming you're using some reasonably testable API to fetch any awaitables within your async method, you should be okay. (Admittedly in the current .NET framework that excludes rather a lot of classes... but the synchronous versions of those calls are also generally hard to test too.)

The plan

For our majority tests, we want to be able to see what happens in various scenarios, with tasks completing at different times and in different ways. Looking at the test cases I've implemented I have the following tests:

• NullSequenceOfTasks
• EmptySequenceOfTasks
• NullReferencesWithinSequence
• SimpleSuccess
• InputOrderIsIrrelevant
• MajorityWithSomeDisagreement
• MajorityWithFailureTask
• EarlyFailure
• NoMajority

I'm not going to claim this is a comprehensive set of possible tests - it's a proof of concept more than anything else. Let's take one test as an example: MajorityWithFailureTask. The aim of this is to pass three tasks (of type Task<string>) into the method. One will give a result of "x", the second will fail with an exception, and the third will also give a result of "x". The events will occur in that order, and only when all three results are in should the returned task complete, at which point it will also have a success result of "x".

So, the tricky bit (compared with normal testing) is introducing the timing. We want to make it appear as if tasks are completing in a particular order, at predetermined times, so we can check the state of the result between events.

Introducing the TimeMachine class

Okay, so it's a silly name. But the basic idea is to have something to control the logical flow of time through our test. We're going to ask the TimeMachine to provide us with tasks which will act in a particular way at a given time, and then when we've started our async method we can then ask it to move time forward, letting the tasks complete as they go. It's probably best to look at the code for MajorityWithFailureTask first, and then see what the implementation of TimeMachine looks like. Here's the test:

[Test]
public void MajorityWithFailureTask()
{
    var timeMachine = new TimeMachine();
    // Second task gives a different result
    var task1 = timeMachine.AddSuccessTask(1, "x");
    var task2 = timeMachine.AddFaultingTask<string>(2, new Exception("Bang!"));
    var task3 = timeMachine.AddSuccessTask(3, "x");

    var resultTask = MoreTaskEx.WhenMajority(task1, task2, task3);
    Assert.IsFalse(resultTask.IsCompleted);

    // Only one result so far - no consensus
    timeMachine.AdvanceTo(1);
    Assert.IsFalse(resultTask.IsCompleted);

    // Second result is a failure
    timeMachine.AdvanceTo(2);
    Assert.IsFalse(resultTask.IsCompleted);

    // Third result gives majority verdict
    timeMachine.AdvanceTo(3);
    Assert.AreEqual(TaskStatus.RanToCompletion, resultTask.Status);
    Assert.AreEqual("x", resultTask.Result);
}

As you can see, there are two types of method:

• AddSuccessTask / AddFaultingTask / AddCancelTask (not used here) - these all take the time at which they're going to complete as their first parameter, and the method name describes the state they'll reach on completion. The methods return the task created by the time machine, ready to pass into the production code we're testing.
• AdvanceTo / AdvanceBy (not used here) - make the time machine "advance time", completing pre-programmed tasks as it goes. When those tasks complete, any continuations attached to them also execute, which is how the whole thing hangs together.

Now forcing tasks to complete is actually pretty simple, if you build them out of TaskCompletionSource<T> to start with. So all we need to do is keep our tasks in "time" order (which I achieve with SortedList), and then when we're asked to advance time we move through the list and take the appropriate action for all the tasks which weren't completed before, but are now. I represent the "appropriate action" as a simple Action, which is built with a lambda expression from each of the Add methods. It's really simple:

public class TimeMachine
{
    private int currentTime = 0;
    private readonly SortedList<int, Action> actions = new SortedList<int, Action>();

    public int CurrentTime { get { return currentTime; } }

    public void AdvanceBy(int time)
    {
        AdvanceTo(currentTime + time);
    }

    public void AdvanceTo(int time)
    {
        // Okay, not terribly efficient, but it's simple.
        foreach (var entry in actions)
        {
            if (entry.Key > currentTime && entry.Key <= time)
            {
                entry.Value();
            }
        }
        currentTime = time;
    }

    public Task<T> AddSuccessTask<T>(int time, T result)
    {
        TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
        actions[time] = () => tcs.SetResult(result);
        return tcs.Task;
    }

    public Task<T> AddCancelTask<T>(int time)
    {
        TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
        actions[time] = () => tcs.SetCanceled();
        return tcs.Task;
    }

    public Task<T> AddFaultingTask<T>(int time, Exception e)
    {
        TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
        actions[time] = () => tcs.SetException(e);
        return tcs.Task;
    }
}

Okay, that's a fair amount of code for a blog posts (and yes, it could do with some doc comments etc!) but considering that it makes life testable, it's pretty simple.

So, is that it?

It works on my machine... with my test runner... in simple cases...

When I first ran the tests using TimeMachine, they worked almost immediately. This didn't surprise me nearly as much as it should have done. You see, when the tests execute, they use async/await in the normal way - which means the continuations are scheduled on "the current task scheduler". I have no idea what the current task scheduler is in unit tests. Or rather, it feels like something which is implementation specific. It could easily have worked when running the tests from ReSharper, but not from NCrunch, or not from the command line NUnit test runner.

As it happens, I believe all of these run tests on thread pool threads with no task scheduler allocated, which means that the continuation is attached to the task to complete "in-line" - so when the TimeMachine sets the result on a TaskCompletionSource, the continuations execute before that call returns. That means everything happens on one thread, with no ambiguity or flakiness - yay!

However, there are two problems:

• The words "I believe" aren't exactly confidence-inspiring when it comes to testing that your software works correctly.
• Our majority voting code only ever sees one completed task at a time - we're not testing the situation where several tasks complete so quickly together that the continuation doesn't get chance to run before they've all finished.

Both of these are solvable with a custom TaskScheduler or SynchronizationContext. Without diving into the docs, I'm not sure yet which I'll need, but the aim will be:

• Make TimeMachine implement IDisposable
• In the constructor, set the current SynchronizationContext (or TaskScheduler) to a custom one having remembered what the previous one was
• On disposal, reset the context
• Make the custom scheduler keep a queue of jobs, such that when we're asked to advance to time T, we complete all the appropriate tasks but don't execute any continuations, then we execute all the pending continuations.

I don't yet know how hard it will be, but hopefully the Parallel Extensions Samples will help me.

Conclusion

I'm not going to claim this is "the" way of unit testing asynchronous methods. It's clearly a proof-of-concept implementation of what can only be called a "test framework" in the loosest possible sense. However, I hope it gives an example of a path we might take. I'm looking forward to seeing what others come up with, along with rather more polished implementations.

Next time, I'm going to shamelessly steal an idea that a reader mailed me (with permission, of course). It's insanely cool, simple and yet slightly brain-bending, and I suspect will handy in many situations. Love it.

Source: http://feedproxy.google.com/~r/JonSkeetCodingBlog/~3/DnRbqgbMyKE/eduasync-part-17-unit-testing.aspx

NOVELLUS SYSTEMS NOVELL NETWORK APPLIANCE

Eduasync part 9: generated code for multiple awaits

Last time we looked at a complex async method with nested loops and a single await. This post is the exact opposite - the method is going to look simple, but it will have three await expressions in. If you're glancing down this post and feel put off by the amount of code, don't worry - once you've got the hang of the pattern, it's really pretty simple.

Here's the async method we're going to analyze:

private static async Task<int> Sum3ValuesAsyncWithAssistance()
{
    Task<int> task1 = Task.Factory.StartNew(() => 1);
    Task<int> task2 = Task.Factory.StartNew(() => 2);
    Task<int> task3 = Task.Factory.StartNew(() => 3);


    int value1 = await task1;
    int value2 = await task2;
    int value3 = await task3;

    return value1 + value2 + value3;
}

Nice and straightforward: start three tasks, then sum their results. Before we look at the decompiled code, it's worth noting that writing it this way allows the three (admittedly trivial tasks) to run in parallel. If we'd written it this way instead:

private static async Task<int> Sum3ValuesAsyncWithAssistance()
{
    // No parallelism...
    int value1 = await Task.Factory.StartNew(() => 1);
    int value2 = await Task.Factory.StartNew(() => 2);
    int value3 = await Task.Factory.StartNew(() => 3);

    return value1 + value2 + value3;
}

... then we'd have waited for the first task to finish before starting the second one, then waited for the second one to complete before we started the third one. That's appropriate when there are dependencies between your tasks (i.e. you need the result of the first as an input to the second) and it would still have been asynchronous but when you can start multiple independent tasks together, that's generally what you want to do. Don't forget that this doesn't just extend to CPU-bound tasks - you might want to launch tasks making multiple web service calls in parallel, before collecting the results.

As before, I'll just show the heart of the generated code, without its boiler-plate skeleton. Again, the full code is available online.

Generated code

  switch (state)
  {
      case 1:
          break;

      case 2:
          goto Label_Awaiter2Continuation;

      case 3:
          goto Label_Awaiter3Continuation;

      default:
          if (state != -1)
          {
              task1 = Task.Factory.StartNew(() => 1);
              task2 = Task.Factory.StartNew(() => 2);
              task3 = Task.Factory.StartNew(() => 3);

              awaiter1 = task1.GetAwaiter();
              if (awaiter1.IsCompleted)
              {
                  goto Label_GetAwaiter1Result;
              }
              state = 1;
              doFinallyBodies = false;
              awaiter1.OnCompleted(moveNextDelegate);
          }
          return;
  }
  state = 0;
Label_GetAwaiter1Result:
  int awaitResult1 = awaiter1.GetResult();
  awaiter1 = new TaskAwaiter<int>();
  value1 = awaitResult1;

  awaiter2 = task2.GetAwaiter();
  if (awaiter2.IsCompleted)
  {
      goto Label_GetAwaiter2Result;
  }
  state = 2;
  doFinallyBodies = false;
  awaiter2.OnCompleted(moveNextDelegate);
  return;
Label_Awaiter2Continuation:
  state = 0;
Label_GetAwaiter2Result:
  int awaitResult2 = awaiter2.GetResult();
  awaiter2 = new TaskAwaiter<int>();
  value2 = awaitResult2;

  awaiter3 = task3.GetAwaiter();
  if (awaiter3.IsCompleted)
  {
      goto Label_GetAwaiter3Result;
  }
  state = 3;
  doFinallyBodies = false;
  awaiter3.OnCompleted(moveNextDelegate);
  return;
Label_Awaiter3Continuation:
  state = 0;
Label_GetAwaiter3Result:
  int awaitResult3 = awaiter3.GetResult();
  awaiter3 = new TaskAwaiter<int>();
  value3 = awaitResult3;

  result = value1 + value2 + value3;

Like last time, I'll just go through the interesting points this raises, rather than examining it line by line.

Switch instead of if

In all our previous async methods, we've only had three possible states: -1 (finished), 0 (normal), 1 (return from continuation). The generated code always looked something like this to start with:

if (state != 1) 
{ 
    if (state == -1) 
    { 
        return; 
    } 
    // Execute code before the first await, loop or try
}

The comment is somewhat brief here, but the basic idea is that all the code which will only ever execute the first time (with no continuations) can go here. If there's a loop that contains an await, then a continuation would have to jump back into that loop, so that code couldn't be contained within this initial block. (A loop which didn't have any awaits in could though.)

Anyway, this time we don't have an "if" statement like that - we have a switch. It's the same idea, but we could be in any of three different states when a continuation is called, depending on which await expression we're at. The switch statement efficiently branches to the right place for a continuation, and executes the initial code otherwise. The "branch" for state 1 is just to exit the switch statement and continue from there.

It's possible that the generated code actually has more levels of indirection than it needs; I don't know about the details of what's allowed within an IL switch, but it seems odd to effectively have an "On X goto Y" where Y immediately performs a "goto Z". If the switch statement could branch immediately to the right label, we'd end up with IL which probably wouldn't have a hope of being decompiled to C#, but which might be slightly more efficient. It's quite likely that the JIT can sort all of that out, of course.

I tend to actually think about all of this as if the code that's really in the "default" case for the switch statement appeared after the switch, and the default case just contained a goto statement to jump to it. The effect would be exactly the same, of course - but it means I have a mental model of the method consisting of a "jump to the right place" phase before an "execute the code" phase. Just because I think of it that way doesn't mean you have to, of course :)

Multiple awaiters and await results

There's room for a bit more optimization in this specific case. We have three awaiters, but they're all of the same type (TaskAwaiter<int>). Likewise, we have three await results, but they're all int. (It would be possible to have different awaiter types with the same result type, of course.)

In the CTP (at least without optimization enabled) we end up with an awaiter / awaitResult pair of variables for each await expression. There's never more than one await "active" at any one time, so the C# compiler could generate one awaiter variable per awaiter type, and one result variable per result type. In the common situation where the result is being directly assigned to a "local" variable of the same type within the method, we don't really need the result variable at all. On the other hand, it's only a local variable (unlike the awaiter) and it's quite possible that the JIT can optimize this instead.

Ultimately it's entirely reasonable for the C# compiler to be generating suboptimal code at this point in the development cycle. After all, it could be quite easy to introduce bugs due to inappropriate code generation... as we'll see next time.

Conclusion

Other than the different way of getting to the right place on entry (using a switch instead of an if statement), async methods with multiple await expressions aren't that hard to follow. Of course when you combine multiple awaits with loops, try/catch, try/finally blocks and any number of other things you might use to complicate the async method, things become tricky - but with the fundamentals covered in this blog series, hopefully you'd be able to cope with the generated code in any reasonable situation. Of course, it's rare that you'll need (or want) to look at the generated code in anything like the detail we have here - but now we've looked at it, you don't need to wonder where the magic happens.

The next post will be the last one involving the decompiled code, at least for the moment. I'd like to demonstrate a bug in the CTP - mostly to show you how a small change to the async method can trigger the wrong results. I'm absolutely positive it will be fixed before release - probably for the next CTP or beta - but I think it's interesting to see the sort of situation which can cause problems.

After that, we're going to look at exception handling, before we move into a few odd way of using async - in particular, implementing coroutines and "COMEFROM".

Source: http://feedproxy.google.com/~r/JonSkeetCodingBlog/~3/-XnM1y9rljI/eduasync-part-9-generated-code-for-multiple-awaits.aspx

SPSS SPANSION SONUS NETWORKS

LINQ To Objects and the performance of nested "Where" calls

This post came out of this Stack Overflow question, which essentially boils down to which is better out of these two options:

var oneBigPredicate = collection.Where(x => Condition1(x)
                                         && Condition2(x)
                                         && Condition3(x));

var multiplePredicates = collection.Where(x => Condition1(x))
                                   .Where(x => Condition2(x))
                                   .Where(x => Condition3(x))

The first case is logically a single "wrapper" sequence around the original collection, with a filter which checks all three conditions (but applying short-circuiting logic, of course) before the wrapper will yield an item from the original sequence.

The second case is logically a set of concentric wrapper sequences, each applying a filter which checks a single condition. Asking the "outer" wrapper for the next item involves that one asking the "middle" wrapper for the next item, which asks the "inner" wrapper for the next item, which asks the original collection for the next item... the item is then passed "outwards" through the wrappers, with the filters being applied as we go, of course.

Now the two will achieve the same result, and I should say up-front that in most realistic cases, it won't make a significant difference which you use. But realistic cases aren't nearly as interesting to investigate as pathological cases, so I decided to benchmark a few different options for the second case. In particular, I wanted to find out how long it took to iterate over a query in the cases where the condition was either "always true" or "always false" - and vary the depth of nesting. Note that I'm not actually testing the first kind of query shown above... I suspect it wouldn't be terribly interesting, at least compared with the results of the second query.

The simplest way of creating a "collection" of a large size is to use Enumerable.Repeat(), and the simplest way of iterating over the whole sequence is to just call Count() on it... so that's what I do, timing how long the Count() call takes. (I don't actually print out the results of Count(), but with an "always false" predicate I'll get 0, and with an "always true" predicate I'll get the size of the input collection.)

Here's the sample code:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

class Test
{
    static void Main()
    {
        int size = 10000000;
        Console.WriteLine("Always false");
        RunTests(size, x => false);
        
        Console.WriteLine("Always true");
        RunTests(size, x => true);
        
    }
    
    static void RunTests(int size, Func<string, bool> predicate)
    {
        for (int i = 1; i <= 10; i++)
        {
            RunTest(i, size, predicate);
        }
    }
    
    static void RunTest(int depth, int size, Func<string, bool> predicate)
    {
        IEnumerable<string> input = Enumerable.Repeat("value", size);
        
        for (int i = 0; i < depth; i++)
        {
            input = input.Where(predicate);
        }
        
        Stopwatch sw = Stopwatch.StartNew();
        input.Count();
        sw.Stop();
        Console.WriteLine("Depth: {0} Size: {1} Time: {2}ms",
                          depth, size, sw.ElapsedMilliseconds);
    }
}

You may notice there's no JIT warm-up here - but I've tried that, and it doesn't alter the results much. Likewise I've also tried with a larger size of collection, and the trend is the same - and the trend is the interesting bit.

Time to guess the results...

Before I include the results, I'll explain what I thought would happen. I had the mental model I described before, with multiple sequences feeding each other.

When the condition is always false, I'd expected the call to MoveNext() from Count() to get all the way to the innermost filtering sequence, which would then iterate over all of the input collection, applying the filter on each item and never yielding a result. That innermost MoveNext() call returns false, and that propagates right back to Count(). All the (significant) time is spent in the innermost loop, testing and rejecting items. That shouldn't depend on the depth of the nesting we've got, right? I'd expect it to be linear in terms of the size of the collection, but constant in terms of nesting. We'll see.

When the condition is always true, we're in a much worse situation. We need to propagate every item from the collection through all the filters, out to Count(), checking the condition and accepting the item on each check. Each MoveNext() call has to go all the way to the innermost filter, then the result has to propagate out again. That sounds like it should be roughly linear in the depth of the nesting, as well as still being linear in the size of the collection - assuming a very simplistic execution model, of course.

Before you look at the results, check that you understand my logic, and see if you can think why it might not be the case.

The actual results

Here's what I've actually observed, with all times in milliseconds. The size of the collection is constant - we're only varying the depth

Depth	Time for "always false"	Time for "always true"
1	182	305
2	219	376
3	246	452
4	305	548
5	350	650
6	488	709
7	480	795
8	526	880
9	583	996
10	882	1849

There are a few things to note here:

• The "always true" time is going up broadly linearly, as we'd expected
• The "always false" time is also going going up broadly linearly, even though we'd expected it to be roughly constant
• The "always false" time is still significantly better than the "always true" time, which is somewhat reassuring
• The performance at a depth of 10 is significantly worse than at a depth of 9 in both cases

Okay, so that's bizarre. What can possibly be making the time taken by the "inner" filtering sequence go up with the depth of the nesting? It shouldn't know about the rest of the calls to Where - that's not its job. Time to investigate...

Reimplementing Where

As you may have seen before, Where isn't very hard to implement - at least it's not hard to implement if you're not trying to be clever. In order to mess around with things to check that my mental model was correct, I decided to run exactly the same tests again, but against the Edulinq implementation. This time, the results are very different:

Depth	Time for "always false"	Time for "always true"
1	232	502
2	235	950
3	256	1946
4	229	2571
5	227	3103
6	226	3535
7	226	3901
8	232	4365
9	229	4838
10	226	5219

Well look at that... suddenly our "always false" query has the expected characteristics. The "always true" query is basically linear except for the jump in time taken between a depth of 2 and a depth of 3. This may well be the same sort of discontinuity present in the earlier results, but at a different depth. (I'll do more research on that another time, I think.)

So if the naive implementation actually works better in some cases, what's going wrong in the "always false" case in the real LINQ to Objects? We can work this out by taking a stack trace from a predicate. Here's a sample query which will throw an exception:

var query = Enumerable.Repeat("value", 1)
                      .Where(x => { throw new Exception("Bang!"); })
                      .Where(x => true)
                      .Where(x => true)
                      .Where(x => true)
                      .Where(x => true)
                      .Where(x => true)
                      .Where(x => true)
                      .Where(x => true);

When you try to count that query (or do anything else which will iterate over it) you get a stack trace like this:

Unhandled Exception: System.Exception: Bang!
   at Test.<Main>b__0(String x)
   at System.Linq.Enumerable.<>c__DisplayClassf`1.<CombinePredicates>b__e(TSource x)
   at System.Linq.Enumerable.<>c__DisplayClassf`1.<CombinePredicates>b__e(TSource x)
   at System.Linq.Enumerable.<>c__DisplayClassf`1.<CombinePredicates>b__e(TSource x)
   at System.Linq.Enumerable.<>c__DisplayClassf`1.<CombinePredicates>b__e(TSource x)
   at System.Linq.Enumerable.<>c__DisplayClassf`1.<CombinePredicates>b__e(TSource x)
   at System.Linq.Enumerable.<>c__DisplayClassf`1.<CombinePredicates>b__e(TSource x)
   at System.Linq.Enumerable.<>c__DisplayClassf`1.<CombinePredicates>b__e(TSource x)
   at System.Linq.Enumerable.WhereEnumerableIterator`1.MoveNext()
   at System.Linq.Enumerable.Count[TSource](IEnumerable`1 source)
   at Test.Main()

Ooh, look at that stack - we've got 8 Where clauses, and 7 levels of DisplayClassf`1 - which looks like a generated class, perhaps for a lambda expression.

Between this and a helpful email from Eric Lippert, we can basically work out what's going on. LINQ to Objects knows that it can combine two Where clauses by just constructing a compound filter. Just for kicks, let's do the same thing - almost certainly more simplistically than LINQ to Objects - but in a way that will give the right idea:

// We could have an interface for this, of course.
public class FilteredEnumerable<T> : IEnumerable<T>
{
    private readonly IEnumerable<T> source;
    private readonly Func<T, bool> predicate;
    
    internal FilteredEnumerable(IEnumerable<T> source,
                                Func<T, bool> predicate)
    {
        this.source = source;
        this.predicate = predicate;
    }
    
    public IEnumerator<T> GetEnumerator()
    {
        foreach (T item in source)
        {
            if (predicate(item))
            {
                yield return item;
            }
        }
    }
    
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    
    public FilteredEnumerable<T> Where(Func<T, bool> extraPredicate)
    {
        return new FilteredEnumerable<T>(source,
                                         x => this.predicate(x) && extraPredicate(x));
    }
}

public static class Extensions
{
    public static IEnumerable<T> Where<T>(this IEnumerable<T> source,
                                          Func<T, bool> predicate)
    {
        var filtered = source as FilteredEnumerable<T>;
        return filtered == null ? new FilteredEnumerable<T>(source, predicate)
                                : filtered.Where(predicate);
    }
}

Let's run the same tests as before, and see how we do...

Depth	Time for "always false"	Time for "always true"
1	240	504
2	275	605
3	332	706
4	430	797
5	525	892
6	558	980
7	638	1085
8	715	1208
9	802	1343
10	1312	2768

Oh look - it feels like the real LINQ to Objects implementation. A bit slower, certainly, but that's okay. The way it trends is the same. In particular, it's slower than the naive implementation for the "always false" filter, but faster for the "always true" filter.

Could things be improved?

The problem here is the creation of nested delegates. We end up with a large stack (which appears to be causing a bigger problem when it reaches a depth of 10) when really we want to just build another delegate.

The thought occurs that we could potentially use expression trees to do this. Not in a signature-compatible way with LINQ to Objects, but we should be able to combine (a => a == 3) and (b => b != 10) into (x => x == 3 && x != 10) effectively. Then when we're asked to iterate, we just need to compile the expression tree to a delegate, and filter using that single, efficient delegate.

There are three problems with this:

• It goes against the normal approach of LINQ to Objects, using delegates instead of expression trees. Heck, with expression trees throughout we could do all kinds of interesting optimizations.
• Creating and compiling the expression tree may be more expensive than the iteration - we don't really know. It depends on how large the collection is, etc.
• It's somewhat complicated to implement, because we need to rewrite the constituent expressions; note how "a" and "b" both become "x" in the example above. This is the main reason I haven't actually bothered trying this in order to benchmark it :)

There are various other options to do with building a more efficient way of evaluating the predicates. One pretty simple (but repetitive) solution is to have one class per number of predicates, with a field per predicate - FilteredEnumerable1, FilteredEnumerable2 etc. When you get bored (e.g. FilteredEnumberable9) you construct any further ones by combining predicates as per the LINQ to Objects approach. For example, here's an implementation of FilteredEnumerable3:

public class FilteredEnumerable3<T> : IFilteredEnumerable<T>
{
    private readonly IEnumerable<T> source;
    private readonly Func<T, bool> predicate0;
    private readonly Func<T, bool> predicate1;
    private readonly Func<T, bool> predicate2;
    
    internal FilteredEnumerable3(IEnumerable<T> source,
                                 Func<T, bool> predicate0,
                                 Func<T, bool> predicate1,
                                 Func<T, bool> predicate2)
    {
        this.source = source;
        this.predicate0 = predicate0;
        this.predicate1 = predicate1;
        this.predicate2 = predicate2;
    }
    
    public IEnumerator<T> GetEnumerator()
    {
        foreach (T item in source)
        {
            if (predicate0(item) &&
                predicate1(item) &&
                predicate2(item))
            {
                yield return item;
            }
        }
    }
    
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    
    public IFilteredEnumerable<T> Where(Func<T, bool> extraPredicate)
    {
        return new FilteredEnumerable4<T>(source,
            predicate0,
            predicate1,
            predicate2,
            extraPredicate);
    }
}

In this case, I'm rather pleased with the results:

Depth	Time for "always false"	Time for "always true"
1	237	504
2	231	551
3	231	599
4	225	625
5	228	703
6	224	787
7	222	876
8	225	966
9	232	1069
10	219	1191

Now that's more like it. Other than a few cells, we're actually outperforming LINQ to Objects - and still compatible with it. The only problem is that the cells where it's slower are the common ones - the top few in the right hand column. And this was just going up to FilteredEnumerable4<T>.

I honestly don't know why my FilteredEnumerable1<T> is slower than whatever's in LINQ to Objects. But it's nice to see the rest going quickly... I suspect there are some downsides as well, and basically I trust the team to make the right decisions for normal cases.

And there's more...

You may be surprised to hear I've kept things simple here - as Eric mentioned to me, it's not just Where and Select that can be transformed in this way. Select works as well - you can combine projections together pretty easily. So imagine that we've effectively got this transformation:

// Normal LINQ query
var query = list.Where(x => Condition1(x))
                .Where(x => Condition2(x))
                .Select(x => Projection1(x))
                .Select(y => Projection2(y));

// After optimization
var query = list.WhereSelect(x => Condition1(x) && Condition2(x),
                             x => Projection2(Projection1(x));

Of course at that point, my FilteredEnumerableX<T> approach becomes even more unwieldy as you have two axes - the number of predicates and the number of projections.

Conclusion

As is so often the case with performance, there's more to Where than there first appears. When I started benchmarking this I had no idea what I was getting myself into. The great thing is that very few people would ever need to know this. It's all hidden by the abstraction.

Still, isn't this sort of thing fun?

Source: http://feedproxy.google.com/~r/JonSkeetCodingBlog/~3/P6gnvqhxDGA/linq-to-objects-and-the-performance-of-nested-quot-where-quot-calls.aspx

INTEL INSIGHT ENTERPRISES INGRAM MICRO

Akademy FR at Capitole du Libre

Last weekend I went back to the beautiful city of Toulouse for Capitole du Libre, a free software event made of three co-hosted events: Akademy FR, Ubuntu Party and Drupal Camp. It was great to meet the usual gang of Toulibre KDE people and put faces on people I only knew from #kde-fr, the friendly French-speaking Freenode IRC channel. We even had Aleix Pol, of KDevelop and KAlgebra fame, coming from Barcelona to help us.

Saturday

Saturday, was the busiest day: we had a KDE booth and ran two conference tracks: users and contributors.

Being co-hosted with the Ubuntu Party brought in a different population from previous KDE Release Parties. We had nice conversations on the KDE booth with Ubuntu users who heard about KDE but did not really know what it looked like or even what it really was. We did our best to sell our beautiful products. The Plasma Active powered Wetab tablet made a very good impression. It is interesting how people had a much easier time understanding the concept of activities on the tablet than on traditional desktops.

Unfortunately I didn’t take any picture of the booth except for this one, our DIY KDE logo. Yes, it could have used an extra row at the bottom, but we were running out of “K”!

The conference tracks were quite packed as well. I gave a presentation on QML development, which went OK I think. My slides should be online soon. I wanted to attend the MyPaint presentation but it was unfortunately scheduled at the same time as mine. Will look at the video.

Sunday

Sunday was dedicated to workshops. It was a lot less crowded: the workshops mostly attracted people who were already familiar with free software. I attended Zanshin workshop. One of my many side-projects is a todo list system so I have to keep an eye on the competition Since I am a nice guy, I put together Ubuntu 11.10 packages for Zanshin 2.0 in my PPA.

After a nice pizza-powered lunch, I spent some time chatting with various people before leaving to Toulouse airport. The event was great, I hope there will be another one next year!

Source: http://agateau.wordpress.com/2011/12/01/akademy-fr-at-capitole-du-libre/

KEY JDS UNIPHASE JDA SOFTWARE GROUP

KDE Telepathy 0.2 Released

We are pleased to announce the second release of KDE Telepathy.

KDE Telepathy is a suite of applications which together form an instant-messaging client allowing you to talk on Jabber, Gmail, Facebookm, MSN and much more. KDE Telepathy stands out from previous instant messaging clients by being able to integrate into the KDE workspace and plasma, as well as being able to be used like a traditional IM application.

This release features:

• KWallet integration for storing of passwords
• A plasmoid for instant access to a contact
• Ability to set your status to the currently playing track from Amarok, Clementine or any other mpris2-compatiable player
• Auto Away
• Progress bar and cancel button for file transfers
• Over 130 bug fixes and tweaks since 0.1!

Sprints

The whole team met at the Woshibon 2 sprint in Cambridge, UK (14th-18th September). This sprint was sponsored by both the KDE e.V and Collabora and allowed us to not only sort out many of the details in making this release, but planning out more long term goals as well.

The Future

This is still a very early release and far from what we want to call the "finished product", however all the functionality works and many of us now use it as a daily instant messaging client.

In the future we shall have contact aggregation, audio and video calls as well as more plasma integration, and much more!

We always appreciate the help from more developers, designers and testers; so if you are interested in helping please check out our wiki page at http://community.kde.org/Real-Time_Communication_and_Collaboration or join in IRC at #kde-telepathy on freenode.

Getting the Latest Release

The latest tarballs are available from KDE's FTP server
http://download.kde.org/download.php?url=unstable/telepathy-kde/0.2.0/src/ .

Be sure to check our wiki page for installation guidelines and troubleshooting help.

Packages may be available for your distribution.

Other News

I'm stepping down as manager for the 0.3 release. I have another project I want to work on as well as a tonne of uni work over the Christmas period. I'm handing over to the nearly as awesome Martin Klapetek to sort things out.

Source: http://www.sharpley.org.uk/node/25

TOTAL SYSTEM SERVICES TNS TIBCO SOFTWARE

Being respective of your time, as well as others - John Mertic

One of the biggest challenges I?ve run into in being a ?remotee? is the daily interaction with other team members. When you are just a cube, an office, or a desk away, there?s always that common water cooler or coffee pot that provides a natural place to interact with others. Or, if you have a question, you can always just stop and ask. Being able to physically get together without having to make much effort is a real bonus for people working in the same office, but can be a bit more challenging if you are remote team member. But this can also be a blessing in disguise, allowing you to concentrate on projects more and be interrupted less often.

What many people don?t realize is that every interaction with fellow team member or collegue is a meeting, and having that meeting is taking he or she away from thier normal duties. Organizations don?t hire people to be in meetings all day, they hire them to be productive contributors to making the organzation as a whole successful. This is where being remote has it?s advantage, as it?s easier to turn off the outside world by turning off your virtual links where in an office you have to hide somewhere to when you need some heads down time.

I recently read the book ?Read This Before Our Next Meeting?, which talks about how to improve the quality of the meetings you hold, and at the same time eliminate those pointless meetings that drag your team down. The big takeaway I had from the book is that you need to be respectful of other people?s time. How do you best do this in the context of meetings? Here?s some good starting points:

• Every meeting should have an agenda, a purpose, and a goal. This helps avoid those ?open discussion? types of meetings which can quickly diverge away from what you are really meeting about. A meeting should have a clear purpose that is communicated to the attendees an agenda that everyone has before the meeting so they are ready to discuss the talking points to be addressed. And in end, there should be some tangible goal to be achieved by having a meeting, whether this is a decision to make or action items for people to take out of the meeting to work on separately.
• Keep meetings short and to the point. Avoid blocking out an hour of someone?s time for a meeting when 15 or 30 minutes will do. This also helps keep you on topic and focused, forcing you to avoid the conversation from spinning out of control.
• Invite only who should be there. Sometimes we like to play the politics game and make sure certain people are at a meeting. Other times we are worried about ?making descions behind closed doors? and thus overinvite to make sure nobody feel out of the loop. If someone really just wants to know what happened, but not really needing to contribute, then take notes or record the session so they can review later. Then if they feedback they can follow up outside of the meeting. The goal here is to have less people in a meeting, which reduces the chances of a meeting spinning wildly out of control.
• Use smaller meetings for planning, and larger meetings for approval. A friend of mine once told me that the best meeting is one where the decision has already been made, you are just getting everyone?s OK on that decision. I completely agree with this; smaller meetings are great to brainstorm since you can easily have a discussion, but with each person you add keeping everyone on topic gets harder and harder. It?s best to bring a plan to a meeting to have it approved or rejected, then outside of the meeting deal with all the details.

What are your pointers for effective meetings and finding ways to be respectful of people?s time? Let me know in comments.

Truncated by Planet PHP, read more at the original (another 658 bytes)

Source: http://jmertic.wordpress.com/2011/11/29/being-respective-of-your-time-as-well-as-others/

QLOGIC PROGRESS SOFTWARE PLANAR SYSTEMS

UsWare, the better way to make software. Better.

Source: http://yacoding.blogspot.com/2008/04/usware-better-way-to-make-software.html

TIBCO SOFTWARE TIBCO SOFTWARE THQ

How version control works

Source: http://yacoding.blogspot.com/2007/11/how-version-control-works.html

LINEAR TECHNOLOGY LEXMARK INTERNATIONAL LEVEL 3 COMMUNICATIONS

What is this thing you call a "type"? Part Two

Well that was entirely predictable; as I said last time, if you ask ten developers for a definition of "type", you get ten different answers. The comments to the previous article make for fascinating reading!

Here's my attempt at describing what "type" means to me as a compiler writer. I want to start by considering just the question of what a type is and not confuse that with how it is used.

Fundamentally, a type in C# is a mathematical entity that obeys certain algebraic rules, just as natural numbers, complex numbers, quaternions, matrices, sets, sequences, and so on, are mathematical entities that obey certain algebraic rules.

By way of analogy, I want to digress for a moment and ask the question "what is a natural number?" That is, what fundamentally characterizes the numbers 0, 1, 2, 3, ... that we use to describe the positions of items in a sequence and the sizes of everyday collections of things?

This question has received a lot of attention over the centuries; the definitive answer that we still use today was created by Giuseppe Peano in the 19th century. Peano said that a natural number is defined as follows:

• Zero is a natural number.
• Every natural number has a "successor" natural number associated with it.
• No natural number has zero as its successor.
• Unequal natural numbers always have unequal successors.
• If you start from zero, take its successor, and then take the successor of that, and so on, you will eventually encounter every natural number. (*)

Surprisingly, that's all you need. Any mathematical entity that satisfies those postulates is usable as a natural number. (**) Notice that there's nothing in there whatsoever about adding natural numbers together, or subtracting, multiplying, dividing, taking exponents, and so on. All of those things can be bolted on as necessary. For example, we can say that addition is defined as follows:

• (n + 0) = n
• (n + (successor of m)) = ((successor of n) + m)

And you're done; you've got a recursive definition of addition. We can similarly define "less than":

• (n < 0) = false
• (0 < (successor of m)) = true
• ((successor of n) < (successor of m)) = (n < m)

We can define every operation on natural numbers in this way; try defining multiplication, just for fun. (Hint: assume that you've already defined addition.)

We can come up with a similar "axiomatic" definition of "type":

• Object is a type
• "Declared" types are types (note that int, uint, bool, string, and so on can be considered "declared" types for our purposes; the runtime "declares" them for you.)
• If T is a type and n is a positive integer then "n-dimensional array of T" is also a type.

And that's pretty much it as far as "safe" C# 1.0 is concerned. (To be as strict as the Peano axioms for natural numbers we'd want to also throw in some similar safeguards; for example, we don't ever want to be in a situation where the type "one-dimensional array of double" has type equality with the type "int", just as we don't ever want to be in a situation where the successor of a natural number is zero.)

Things get a bit more complex when we throw in generic types and pointer types, but I'm sure you can see that we could come up with a precise axiomatic description of generic types and pointer types with a little bit of work. That is, type parameter declarations are types, generic type declarations constructed with the right number of type arguments are types, and so on.

We can then start piling on algebraic operations. Just as we defined "less than" on numbers, we can define the "is a subtype of" relation on types.

• T <: object is true for any type T that is not object
• object <: T is false for any type T
• if S <: T and T <: U then S <: U
• ... and so on...

Just as I do not care how numbers are "implemented" in order to manipulate them algebraically, I also do not care how types are "implemented" in order to manipulate them with the rules of type algebra. All I care about are the axioms of the system, and the rules that define the algebraic operators that I've made up for my own convenience.

So there you go; we have a definition of "type" that does not say anything whatsoever about "a set of values" or "a name". A type is just an abstract mathematical entity, a bit like a number, that obeys certain defining axioms, and therefore can be manipulated algebraically by making up rules for useful operators -- just like numbers can be manipulated abstractly according to algebraic rules that we make up for them.

Now that we have a sketch of an axiomatic definition of what a type is, what are we going to do with it?

Perhaps the most fundamental purposes of static type checking in a programming language like C# are to associate a type with every relevant storage location, to associate a type with every (†) relevant compile-time expression, and to then ensure that it is impossible for a value associated with an incompatible type to be written to or read from any storage location. A compile-time proof of runtime type safety (‡): that's the goal.

The key word there is proof; now that we have developed an axiomatic definition of "type" we can start constructing proofs based on these axioms. The C# specification defines:

• what type is associated with every compile-time expression; of course, expressions whose types cannot be determined might be program errors
• what type is associated with every storage location
• what constitutes an acceptable assignment from an expression of given type (‡‡ to a storage location of a given type

The task of the compiler writer is then to implement those three parts of the specification: associating a type with every expression, associating a type with every storage location, and then constructing a proof that the assignment is valid given the rules. If the compiler is able to construct a proof then the assignment is allowed. The tricky bit is this: the specification typically just gives the rules of the system, not a detailed algorithm describing how to construct proofs using those rules. If any proof exists then the compiler is required to find it. Conversely, if no proof exists, the compiler is required to deduce that too and produce a suitable compile-time type error.

Unfortunately, as it turns out, that's impossible in general. A system where it is possible for every expression to be classified as either "type safe" or "type unsafe" in a finite number of logical steps is called a "decidable" system. As Gödel famously proved, natural number arithmetic as axiomatized above is undecidable; there are statements in formal arithmetic that can be neither proved nor disproved in a finite number of logical steps. Assignment type checking is also in general undecidable in programming languages with both nominal subtyping (‡‡‡) and generic variance. As I mentioned a while back, it turns out that it would be possible to put additional restrictions on type declarations such that nominal subtyping would become decidable, but we have not ever done this in C#. Rather, when faced with a situation that produces an infinitely long proof of type compatibility, the compiler just up and crashes with an "expression was too complex to analyze" error. I'm hoping to fix that in a hypothetical future version of the compiler, but it is not a high priority because these situations are so unrealistic.

Fortunately, situations where type analysis is impossible in general, or extremely time consuming, are rare in realistic C# programs; rare enough that we can do a reasonable job of writing a fast compiler.

Summing up: A type is an abstract mathematical entity defined by some simple axioms. The C# language has rules for associating types with compile-time expressions and storage locations, and rules for ensuring that the expression type is compatible with the storage type. The task of the compiler writer is to use those axioms and algebraic rules to construct a proof or disproof that every expression has a valid type and that every assignment obeys the assignment compatibility rules.

Though the axioms of what makes a type are pretty simple, the rules of associating types to expressions and determining assignment compatibility are exceedingly complex; that's why the word "type" appears 5000 times in the specification. To a large extent, the C# language is defined by its type rules.

----------------------

(*) I am of course oversimplifying here; more formally, the real axiom formally states that proof by induction works on natural numbers. That is: if a property is true of zero, and the property being true for a number implies the truth for its successor, then the property holds for all numbers.

(**) It is instructive to consider why the third, fourth and fifth postulates are necessary. Without the third postulate, there need only be one number: zero, which is its own successor! Without the fourth postulate we could say that there are only two numbers: the successor of zero is one, the successor of one is one. Without the fifth postulate there could be *two* zeros: "red zero" and "blue zero". The successor of red zero is red one, the successor of blue zero is blue one, and so on. In each case, the system without the axiom satisfies the remaining four axioms, but in each case it seems very contrary to our intuition about what a "natural number" is.

(†) We fudge this in C# of course; null literals, anonymous functions and method groups are technically classified as "expressions without any type". However, in a legal program they must occur in a context where the type of the expression can be inferred from its surrounding context.

(‡) The cast operator gives the lie to this, of course; one meaning of the cast operator is "there is no compile-time proof that this is type safe; I assert that it is safe, so generate code that checks my assertion at runtime." Also, unsafe array covariance makes this goal unreachable.

(‡‡) Again, this is fudged in a few places. For example, it is not legal to assign an expression of type int to a variable of type short, unless the expression of type int is a compile-time constant known to fit into a short.

(‡‡‡) That is, a language where you state the base type of a newly declared type. Like "interface IFoo<T> : IBar<T>" uses nominal subtyping.

Source: http://blogs.msdn.com/b/ericlippert/archive/2011/09/07/what-is-this-thing-you-call-a-quot-type-quot-part-two.aspx

VIRGIN MEDIA VIEWSONIC VERISIGN

The Gamification

When Joel Spolsky and I set out to design the Stack Exchange Q&A engine in 2008 -- then known as Stack Overflow -- we borrowed liberally and unapologetically from any online system that we felt worked. Some of our notable influences included:

• Reddit and Digg voting
• Xbox 360 achievements
• Wikipedia editing
• eBay karma
• Blogs and blog comments
• Classic web bulletin boards

All these elements were folded up into the Stack Exchange Q&A engine, so that we might help people create useful artifacts on the internet while learning with and among their peers. You know the old adage that good artists copy, great artists steal? That quote is impossible to source, but it means we were repurposing these elements we liked.

So, what do Picasso and T.S. Eliot mean? They say, in the briefest of terms: take old work to a new place. Steal the Google site, strip down what works (fast load, nonexistent graphics, small quirky changes that delight) and use the parts on your own site. Look at the curve of a Coke Bottle and create a beautiful landscape painting with it. Take the hairline pinstriping on the side of somebody?s car, reimagine it on your print job. Find inspiration in the world you live in, where nothing is truly new so that everything has the potential to be innovative.

Unfortunately, the elements we liked were often buried in mounds of stuff that we ... sort of hated. So extracting just the good parts and removing the rest was part of the mission. If you're lucky enough to have a convenient villain to position yourself against, that might be all you need.

Traditional web bulletin board systems have a design that was apparently permanently frozen in place circa 2001 along with Windows XP. Consider this typical forum thread.

Here is the actual information from that forum thread.

Based on the original size of those screenshots, only 18 percent of that forum thread page is content. The other 82 percent is lost to signatures, avatars, UI doohickeys, and other web forum frippery that has somehow become accepted as "the way things are done". I regularly participate in several expert niche bulletin boards of various types today, and they're all built the same way. Nobody complains.

But they should.

This is the status quo that we're up against. Yes, we fixed it for programmers with Stack Overflow, but why stop there? We want to liberate all the brilliant experts stuck in these horrible Soviet-era concrete block housing forums all over the web. We'd like to introduce them to the focused, no-nonsense Stack Exchange Way, a beautiful silo of pure Q&A signal without all the associated web forum gunk.

There's only one teeny-tiny obstacle in our way. As a great programmer I worked with once said:

It's the damn users. They've ruined every program I've ever created.

Every web forum is the way it is because users wanted it that way. Yes, the design of the forum software certainly influences behavior, but the classic 2001-era web forum paradigm assumed that what users wanted made sense for the rest of the larger internet. As it turns out, groups are their own worst enemy. What groups want, and what the rest of the world needs, are often two very different things. Random discussion is fine for entertainment, but it's not particularly useful, nor does it tend to generate the kind of artifacts that will be relevant a few years from now like Wikipedia does. So then the problem becomes how do you encourage groups to do what's best for the world rather than their own specific, selfish needs?

When I looked at this problem, I felt I knew the answer. But there wasn't a word for it in 2008. Now there is: Gamification.

Gamification is the use of game design techniques and mechanics to solve problems and engage audiences. […] Gamification works by … taking advantage of humans' psychological predisposition to engage in gaming. The technique can encourage people to perform chores that they ordinarily consider boring, such as completing surveys, shopping, or reading web sites.

I had no idea this Wikipedia article even existed until a few months ago, but we are featured prominently in it. It is true that all our stolen ideas about reputation systems, achievements, identity, and vote scoring are in place specifically to encourage the adoption of the brave new no-nonsense, all-signal Stack Exchange Q&A model. Without those incentive systems, when left to their own devices, what you get is … well, every forum ever created. Broken by design.

Yes, we have ulterior motives, but let me explain why I think gaming elements are not tacked on to the Stack Exchange Q&A engine, but a natural and essential element of the design from day one.

Learning is (supposed to be) fun

I've had this concept in my head way before the web emerged, long before anyone coined the term "Gamification" in 2010. In fact, I'd trace my inspiration for this all the way back to 1983.

For programmers, everything we know is pretty much guaranteed to be obsolete in 10 years if we're lucky, and 5 years if we aren't. It's changing all the time. The field of programming is almost by definition one of constant learning. Programming is supposed to be fun – and it is, if you're doing it right. Nobody taught me that better than the Beagle Bros on my Apple II. Why can't learning in every other subject matter be just as enjoyable?

Games are learning aids

There's a long, rich history of programmers as gamers. Oftentimes, the whole reason we became programmers in the first place is because we wanted to move beyond being a mere player and change the game, control it, modify its parameters, maybe even create our own games.

We used games to learn how to program. To a programmer, a game is a perfectly natural introduction to real programming problems. I'd posit that any field can use games as an introduction to the subject matter – and as a reinforcement to learning.

Games help people work toward a goal

It's something of a revelation to me that solid game design can defeat the Greater Internet F**kwad Theory. Two great examples of this are Counter-Strike and Team Fortress. Both games are more than ten years old, but they're still actively being played right now, by tens of thousands of people, all anonymous … and playing as cohesive teams!

The game's objectives and rules are all cleverly constructed to make working together the most effective way to win. None of these players know each other; the design of the game forces players to work together, whether they want to or not. It is quite literally impossible to win as a single lone wolf.

I haven't ever quite come out and said it this way, but … I played a lot of Counter-Strike from 1998 to 2001, and Stack Overflow is in many ways my personal Counter-Strike. It is a programmer in Brazil learning alongside a programmer in New Jersey. Not because they're friends -- but because they both love programming. The design of Stack Overflow makes helping your fellow programmers the most effective way to "win" and advance the craft of software development together.

And I say we all win when that happens, no matter which profession we're talking about.

I feel a little responsible for "Gamification", since we're often cited as an example (even, much to my chagrin, on Wikipedia). I wanted to clear up exactly why we made those choices, and specifically that all the gaming elements are there in service of a higher purpose. I play the Stack Exchange game happily alongside everyone else, collecting reputation and badges and rank and upvotes, and I am proud to do so, because I believe it ultimately helps me become more knowledgeable and a better communicator while also improving the very fabric of the web for everyone. I hope you feel the same way.

(If you'd like to learn more about the current state of Gamification, I highly recommend Sebastian Deterding's page, and specifically his Meaningful Play: Getting Gamification Right presentation.)

[advertisement] What's your next career move? Stack Overflow Careers has the best job listings from great companies, whether you're looking for opportunities at a startup or Fortune 500. You can search our job listings or create a profile and let employers find you.

Source: http://www.codinghorror.com/blog/2011/10/the-gamification.html

KEY JDS UNIPHASE JDA SOFTWARE GROUP

Recursive component's enumerator in Delphi

Source: http://yacoding.blogspot.com/2008/05/recursive-component-enumerator-in.html

MISCROSOFT OFFICE MICROSOFT MCAFEE

Switched to LuaLaTeX

Hi!

Have you ever tried to write a little bit complex command in LaTeX? I did at some occasions, and finally it somehow worked, but it has always been ugly. However, there is LuaTeX/LuaLaTeX, it provides real scripting within your documents:

\directlua{   for i=0, 15 do     tex.print("Math: $x_{" .. i .. "}$")   end }

That is just awesome, in plain LaTeX this would be ugly, but it gets even more ugly if you have to deal with floating points, external files etc. Well, for now I do not need any complex macro, so I cannot talk about actual experiences with Lua stuff, but I encountered some problems when translating my LaTeX document to LuaLaTeX two weeks ago.

unicode-math does not work properly

When enabling the unicode-math package for using Unicode characters in formulas (⊂∀∃∂ etc.) I have to select a font using the \setmathfont command, I tried “Latin Modern Math”, “STIXGeneral”, “XITS Math”, “Neo Euler” and “Asana Math”, otherwise Unicode symbols will not get displayed. However, with all of these fonts formulas do not look as good as with standard LaTeX lmodern-package, which is usable from LuaLaTeX, too, \setmathfont will override it. Some of them are too bold, some have ugly ℝ, ℚ, ℂ (\mathbb) and \mathcal symbols etc. Thus I decided to port the uniinput package provided by the Neo project (they create the keyboard layout I am using) to LuaLaTeX. I thought it would be nice to check the Lua capabilities that for, however, I faced the next problem.

Lua is not Unicode aware

That is really annoying, LuaLaTeX’s claim is to support a) sophisticated scripting and b) native Unicode support. However, they choosed Lua as scripting language, which does not support Unicode natively. I could not find the functions I needed to write a succinct macro for declaring a Unicode character in math mode (for examble ℝ should be replaced with \mathbb{R}), simply something to split a 8-bit-UTF-8-string into its Unicode characters and to do conversions between character codes and strings. I did not want to write it myself. Thus I choosed a quick and dirty way: using some regexp-magic and a Ruby script to convert uniinput.sty into uniinput-lualatex.sty. It works now, you can use it if you want to…

Making it working with KileIP

KileIP currently has the latex-command hard coded to display previews of formulas. I was too lazy to fix that and I wanted to be able to fall back to LaTeX if there were unexpected problems, thus I made my document working with both LaTeX and LuaLaTeX:

\usepackage{iftex} \ifPDFTeX   \usepackage[utf8]{inputenc}   \usepackage[T1]{fontenc}   \usepackage{uniinput}   \usepackage{lmodern}   \usepackage{amsmath}   \usepackage{amssymb} \else   \ifLuaTeX     \usepackage{luatextra}     \usepackage{amsmath}     \usepackage{amssymb}     \usepackage{lmodern}     \usepackage{uniinput-lualatex}     \usepackage{fontspec}   \fi \fi

Well, next time I need a complex macro I will certainly use Lua and it will hopefully work with my setup.

Source: http://the-user.org/post/switched-to-lualatex

VOLT INFORMATION SCIENCES VISHAY INTERTECHNOLOGY VIRGIN MEDIA

Eduasync part 6: using the infrastructure manually

Now that we've got the infrastructure for both returning a task from an async method, and awaiting a Task<T>, we're going to look at what the compiler does for us. I always find that the best way of appreciating a feature like this is to consider what we'd have to do without it. Later on we're going to see what the C# compiler does in terms of decompiling the actual generated code, but first we'll look at what we might do to achieve the same end result, using the same infrastructure.

Of course, if we were doing all of this manually we might not choose to use the same infrastructure to start with, but I'm not sure that it would end up being much cleaner anyway.

A simple async method

First, let's look at the C# 5 async method we want to emulate. It's pretty simple:

private static async Task<int> ReturnValueAsyncWithAssistance()
{
    Task<int> task = Task<int>.Factory.StartNew(() => 5);

    return await task;
}

Now obviously we could just return the task here to start with - the async method isn't providing any real benefit. But the simplicity is helpful for showing an equivalent. You can always imagine that there's more going on between awaiting the result of the task and returning our actual result.

What do we need to do?

Before I include the actual code, let's consider what we know about the async method execution model:

• We'll create an AsyncTaskMethodBuilder to allow us to return a Task<int>.
• The method will start synchronously, running all the code before the first (and in this case only) await expression in the normal way.
• The awaitable expression will be evaluated, and GetAwaiter() called to get a suitable awaiter value.
• We'll ask the awaiter whether the awaitable has already completed, using the IsCompleted property
  • If it's already completed, we get the result by calling GetResult(). We can set the result on the builder, and return the builder's task.
  • Otherwise, create a continuation delegate representing "the rest of the method". We then return the builder's task.
    • The continuation has to fetch the result by calling GetResult() on the same awaiter, set the result on the builder, and return. (It's not returning a Task<T> - the continuation is just an Action.)
• If an exception occurs at any point, whether in the original synchronous call or the continuation, we need to set that exception in the builder, and return (either returning the builder's task or nothing, depending on the context).

Even describing it makes it sound significantly worse than the async method. Let's take a look.

Bring on the code!

Here's the manual method in all its glory:

private static Task<int> ReturnValueAsyncWithoutAssistance()
{
    AsyncTaskMethodBuilder<int> builder = AsyncTaskMethodBuilder<int>.Create();

    try
    {
        Task<int> task = Task<int>.Factory.StartNew(() => 5);

        TaskAwaiter<int> awaiter = task.GetAwaiter();
        if (!awaiter.IsCompleted)
        {
            // Result wasn't available. Add a continuation, and return the builder.
            awaiter.OnCompleted(() =>
            {
                try
                {
                    builder.SetResult(awaiter.GetResult());
                }
                catch (Exception e)
                {
                    builder.SetException(e);
                }
            });
            return builder.Task;
        }

        // Result was already available: proceed synchronously
        builder.SetResult(awaiter.GetResult());
    }
    catch (Exception e)
    {
        builder.SetException(e);
    }
    return builder.Task;
}

Ugly, isn't it? Even so, it's actually somewhere simpler than the real autogenerated code, which we'll see in the next part. Hopefully if you read the code and comments bearing in mind the bullet points above, it should be reasonably easy to see how it works. However:

• Currently we're building a continuation delegate specific to this particular await. Imagine if we had several await expressions. Each would need "the rest of the method" specified as its own delegate, and we'd end up building multiple delegate instances over time.
• It would be a nightmare to handle loops in this way.
• We've got repeated code - not a lot in this case, but anything we had between the "await" and the "return" would need to be in both flows.
• You don't really want to be writing this code by hand anyway, if you can help it.

Having said all of that, it works. Just don't expect me to write any more complicated async methods this way :)

Conclusion

The steps given here are still going to be valid with the compiler-generated code, but they'll take a slightly different form. Next time we'll decompile the generated code for the exact same async method, before we move on to look at more complicated cases.

Source: http://feedproxy.google.com/~r/JonSkeetCodingBlog/~3/__S8qUTT64g/eduasync-part-6-using-the-infrastructure-manually.aspx

SYKES ENTERPRISES INORATED SYBASE SUN MICROSYSTEMS

Optional argument corner cases, part three

(This is part three of a series on the corner cases of optional arguments in C# 4; part two is here. Part four is here.)

A lot of people seem to think that this:

void M(string x, bool y = false) { ... whatever ... }

is actually a syntactic sugar for the way you used to have to write this in C#, which is:

void M(string x) { M(x, false); }
void M(string x, bool y) { ... whatever ... }

But it is not. The syntactic sugar here is not on the declaration side, but rather on the call side. There is only one method; when you make a call that omits optional arguments, the compiler simply inserts the arguments at the call site. That is:

M("hello");

is rewritten as

M("hello", false);

It would actually be pretty weird if we did it on the declaration side, because what would you do about this?

void N(bool a1 = false, bool a2 = false) { ... whatever ... }

Clearly we can't generate

void N() { N(false, false); }
void N(bool a1) { N(a1, false); }
void N(bool a2) { N(false, a2); }
void N(bool a1, bool a2) { ... whatever ... }

because now we have two methods with the same signature. But why would we need to generate the "a2" method in the first place? Because we added named arguments as well as optional arguments. Someone could call:

N(a2: true);

Clearly we have to rewrite the caller side, not the called side.

An argument with a default value does not change the signature at all, so anything that relies upon signature matching still needs to have an exact match. That is, even though you can say:

M("hello");

and you can say

Action<string> action = (string s)=>{M(s);};

You cannot say

Action<string> action = M;

Because M does not have a signature match with that delegate type; the delegate is expecting a method that takes a string, but you're giving it a method that takes a string and a bool. Where is the code generated that fills in the bool? There is no call site here, and the default value has to be filled in at the call site.

Similarly, you can't do something like this:

class B
{
  public virtual void M(string x, bool y = false) {}
}
class D : B
{
  public override void M(string x) {}
}

Or this:

class D : B
{
  public override void M(string x, bool y = false, int z = 123) {}
}

The signatures have to match to do an override, and default values for missing arguments are not part of the signature.

Next time: more consequences of call-site rewriting.

(This is part three of a series on the corner cases of optional arguments in C# 4; part two is here. Part four is here.)

Source: http://blogs.msdn.com/b/ericlippert/archive/2011/05/16/optional-argument-corner-cases-part-three.aspx

INTERNATIONAL GAME TECHNOLOGY INTERNATIONAL BUSINESS MACHINES (IBM) INTERDIGITAL COMMUNICATIONS

Data URI Test

Source: http://my2iu.blogspot.com/2010/10/data-uri-test.html

VIRGIN MEDIA VIEWSONIC VERISIGN

Code is your least problem

Source: http://yacoding.blogspot.com/2008/05/code-is-your-least-problem.html

SPSS SPANSION SONUS NETWORKS

Scrolling Games in JavaScript

Source: http://my2iu.blogspot.com/2010/10/scrolling-games-in-javascript.html

SONUS NETWORKS SONIC AUTOMOTIVE SKYWORKS SOLUTIONS

Conditional Formatting on Google Docs, farewell excel.

Source: http://yacoding.blogspot.com/2007/10/conditional-formatting-on-google-docs.html

TRANSACTION SYSTEMS ARCHITECTS TOTAL SYSTEM SERVICES TNS

Dynamically Controlling Your Application From The Web

Often times you find yourself in a situation where you might want to control your application remotely. You may want to enable/disable features at a certain time, push messages to all of your users, or do some cross promotion whenever you launch a new application. All of this can easily be done with a little JSON and some simple web interface coding.   In this tutorial, I will show you how to use ASIHTTPRequest along with JSONKIT to fetch, parse, ...

Source: http://feedproxy.google.com/~r/icodeblog/~3/kihi75JS9oM/

SALESFORCE COM SAIC ROCKWELL AUTOMATION

Waiting for table metadata lock and PECL/mysqlnd_ms - Ulf Wendel

The MySQL administration SQL command SHOW PROCESSLIST may read "Waiting for table metadata lock" in its "State" column for a statement. The statement in question is waiting for another transaction to release a metadata lock. Its a state that may appear when using the global transaction ID injection feature of PECL/mysqlnd_ms 1.2.0-alpha. But only in case of errors and if not using default settings of the plugin. In the worst case, during testing only, I experienced a deadlock with MySQL 5.5.3 or higher which never got resolved automatically.

Provoking metadata lock

Let a transaction update a record in a table. In my specific case it was an failing UPDATE. It failed because the table did not exist. Let a second transaction run a DDL statement, for example, DROP TABLE on the same table. The second transaction is now in waiting for the first transaction to release a metadata lock. Yes, the second transaction is waiting for a lock hold on a non-existing table, if you are using MySQL 5.5.3 or higher? The SQL is syntactically correct, thus the lock is acquired.

 $link = new mysqli($host, $user, $passwd, $db, $port, $socket); $link->autocommit(false); $link->query(\"UPDATE foo SET bar = bar + 1\"); 	 $link2 = new mysqli($host, $user, $passwd, $db, $port, $socket); $link2->query(\"DROP TABLE IF EXISTS foo\"); 

 mysql> show processlist; +------+------+--------------------+------+---------+------+---------------------------------+--------------------------+ | Id   | User | Host               | db   | Command | Time | State                           | Info                     | +------+------+--------------------+------+---------+------+---------------------------------+--------------------------+ | 5754 | root | 192.168.78.1:44307 | test | Sleep   |  160 |                                 | NULL                     | | 5755 | root | 192.168.78.1:44308 | test | Query   |  160 | Waiting for table metadata lock | DROP TABLE IF EXISTS foo | | 5756 | root | localhost:60751    | test | Query   |    0 | NULL                            | show processlist         | +------+------+--------------------+------+---------+------+---------------------------------+--------------------------+ 

This behaviour is different from previous MySQL versions and it is documented in the MySQL 5.5.3 Changes as an incompatible change: A table that is being used by a transaction within one session cannot be used in DDL statements by other sessions until the transaction ends. . The change fixed issues with the binary log. So far, so good - though surprising.

Under normal circumstances the server will release the lock when the clients commit their transactions or disconnect. If they don?t end their transactions nicely but die, the wait_timeout should detect failing TCP/IP clients and solve the deadlock.

How its related to the plugin

What I was doing here was simlating a failure of the plugin to inject a global transaction ID because the transaction table was not set up. The injection, the UPDATE fails, when the client is not in autocommit mode. My initial idea was that the plugin would then report and error to the application and the application could create the transaction id table, if it wanted. In my test I tried catching the error and did DROP TABLE IF EXISTS trx_table, CREATE TABLE trx_table to recreate the table. My test timed out. And, that day it was time for me to call it a day.

The other day, I checked the processlist and saw the deadlock. My PHP test had stopped and disconnected but the deadlock still existed and borked numerous other test runs. It was necessary to KILL the sleeping lock holder manually.

Error handling in the plugin

The plugin offers two ways of dealing with injection errors. By default the injection error is ignored and the function called by the application is executed nonetheless. If, for example, we are running in transaction mode (auto commit off), the user calls the commit() function and injection of the UPDATE statement for increasing the transaction counter fails, the plugin commits anyway. The transaction ends. Other transactions should not be blocked because the metadata lock on the transaction table is released by ending the transaction. No matter if using MySQL 5.5.3 or earlier.

 user_commit()    if (!inject_trx_id() && report_error)        return false; 	   return commit() 

Optionally, users can tell the plugin to bubble up the injection error. If so, users should roll back the current transaction calling rollback() to prevent the metadata lock issue. Alternatively, you can check for the error code and try to detect cases when its required to recreate the transaction id table.

Moral

As said, if you go for plugin default settings, no locking issue but possibly gaps and holes in your transaction id table. If you know what you do, if you can adapt your application and code changes are possible, you can manually handle the error and recreate the transaction id table on demand.

Source: http://blog.ulf-wendel.de/2011/waiting-for-table-metadata-lock-and-peclmysqlnd_ms/

TECHNITROL TAKETWO INTERACTIVE SOFTWARE SYNTEL

Koala Framework: Open Source Web Application and CMS Framework

This post is not KDE related, but about Open Source - not entirely off topic on PlanetKDE.

The company I work for recently decided that we release our Framework and CMS as Open Source Software. This is very exciting for all of us and especially me - as I brought that topic on the table again and again. And finally we did it :D

It's a framework to create anything that runs in a browser: from a website or blog to a desktop like web application. It's built on solid grounds: Zend Framework (Php framework) and ExtJS (JavaScript framework).

Screenshot showing an simple example web application [more screenshots]

Screenshot showing the CMS with a text component being edited [more screenshots]

The current state is that the framework is used in our company for lots of different projects, but due to we just got opensource we have no community yet. We are also lacking of good documentation - but we are willing to fix that - if we succeed in building an community around it.

So if you are interested in such a framework visit the Koala Framework website to get more information and join the mailing list.

Source: http://nikosams.blogspot.com/2011/11/koala-framework-open-source-web.html

SUN MICROSYSTEMS STANDARD MICROSYSTEMS SRA INTERNATIONAL

Eduasync part 11: More sophisticated (but lossy) exception handling

(This post covers projects 13-15 in the source code.)

Long-time readers of this blog may not learn much from this post - it's mostly going over what I've covered before. Still, it's new to Eduasync.

Why isn't my exception being caught properly?

Exceptions are inherently problematic in C# 5. There are two conflicting aspects:

• The point of the async feature in C# 5 is that you can write code which mostly looks like its synchronous code. We expect to be able to catch specific exception types as normal.
• Asynchronous code may potentially have multiple exceptions "at the same time". The language simply isn't designed to deal with that in the synchronous case.

Now if the language had been designed for asynchrony to start with, perhaps exception flow would have been designed differently - but we are where we are, and we all expect exceptions to work in a certain way.

Let's make all of this concrete with a sample:

private static void Main(string[] args)
{
    Task<int> task = FetchOrDefaultAsync();
    Console.WriteLine("Result: {0}", task.Result);
}

private static async Task<int> FetchOrDefaultAsync()
{
    // Nothing special about IOException here
    try
    {
        Task<int> fetcher = Task<int>.Factory.StartNew(() => { throw new IOException(); });
        return await fetcher;
    }
    catch (IOException e)
    {
        Console.WriteLine("Caught IOException: {0}", e);
        return 5;
    }
    catch (Exception e)
    {
        Console.WriteLine("Caught arbitrary exception: {0}", e);
        return 10;
    }
}

Here we have a task which will throw an IOException, and some code which awaits that task - and has a catch block for IOException.

So, what would you expect this to print? With the code we've got in Eduasync so far, we get this:

Caught arbitrary exception: System.AggregateException: One or more errors occurred. ---> System.IO.IOException: I/O error occurred.
...
Result: 10

If you run the same code against the async CTP, you get this:

Caught IOException: System.IO.IOException: I/O error occurred.
...
Result: 5

Hmm... we're not behaving as per the CTP, and we're not behaving as we'd really expect the normal synchronous code to behave.

The first thing to work out is which boundary we should be fixing. In this case, the problem is between the async method and the task we're awaiting, so the code we need to fix is TaskAwaiter<T>.

Handling AggregateException in TaskAwaiter<T>

Before we can fix it, we need to work out what's going on. The stack trace I hid before actually show this reasonably clearly, with this section:

at System.Threading.Tasks.Task.ThrowIfExceptional(Boolean includeTaskCanceled Exceptions)
at System.Threading.Tasks.Task`1.get_Result()
at Eduasync.TaskAwaiter`1.GetResult() ...\TaskAwaiter.cs:line 40
at Eduasync.Program.<FetchOrDefaultAsync>d__2.MoveNext() ...\Program.cs:line 37

So AggregateException is being thrown by Task<T>.Result, which we're calling from TaskAwaiter<T>.GetResult(). The documentation for Task<T>.Result isn't actually terribly revealing here, but the fact that Task<T>.Exception is of type AggregateException is fairly revealing.

Basically, the Task Parallel Library is built with the idea of multiple exceptions in mind - whereas our async method isn't.

Now the team in Microsoft could have decided that really you should catch AggregateException and iterate over all the exceptions contained inside the exception, handling each of them separately. However, in most cases that isn't really practical - because in most cases there will only be one exception (if any) and all that looping is relatively painful. They decided to simply extract the first exception from the AggregateException within a task, and throw that instead.

We can do that ourselves in TaskAwaiter<T>, like this:

try
{
    return task.Result;
}
catch (AggregateException aggregate)
{
    if (aggregate.InnerExceptions.Count > 0)
    {
        // Loses the proper stack trace. Oops. For workarounds, see
        // See http://bradwilson.typepad.com/blog/2008/04/small-decisions.html
        throw aggregate.InnerExceptions[0];
    }
    else
    {
        // Nothing better to do, really...
        throw;
    }
}

As you can tell from the comment, we end up losing the stack trace using this code. I don't know exactly how the stack trace is preserved in the real Async CTP, but it is. I suspect this is done in a relatively obscure way at the moment - it's possible that for .NET 5, there'll be a cleaner way that all code can take advantage of.

This code is also pretty ugly, catching the exception only to rethrow it. We can check whether or not the task has faulted using Task<T>.Status and extract the AggregateException using Task<T>.Exception instead of forcing it to be thrown and catching it. We'll see an example of that in a minute.

With our new code in place, we can catch the IOException in our async code very easily.

What if I want all the exceptions?

In certain circumstances it really makes sense to collect multiple exceptions. This is particularly true when you're waiting for multiple tasks to complete, e.g. with TaskEx.WhenAll in the Async CTP. This caused me a certain amount of concern for a while, but when Mads came to visit in late 2010 and we talked it over, we realized we could use the compositional nature of Task<T> and the convenience of TaskCompletionSource to implement an extension method preserving all the exceptions.

As we've seen, when a task is awaited, its AggregateException is unwrapped, and the first exception rethrown. So if we create a new task which adds an extra layer of wrapping and make our code await that instead, only the extra layer will be unwrapped by the task awaiter, leaving the original AggregateException. To come up with a new task which "looks like" an existing task, we can simply create a TaskCompletionSource, add a continuation to the original task, and return the completion source's task as the wrapper. When the continuation fires we'll set the appropriate result on the completion source - cancellation, an exception, or the successful result.

You may expect that we'd have to create a new AggregateException ourselves - but TaskCompletionSource.SetException will already do this for us. This makes it looks like the code below isn't performing any wrapping at all, but remember that Task<T>.Exception is already an AggregateException, and calling TaskCompletionSource.SetException will wrap it in another AggregateException. Here's the extension method in question:

public static Task<T> WithAllExceptions<T>(this Task<T> task)
{
    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();

    task.ContinueWith(ignored =>
    {
        switch (task.Status)
        {
            case TaskStatus.Canceled:
                tcs.SetCanceled();
                break;
            case TaskStatus.RanToCompletion:
                tcs.SetResult(task.Result);
                break;
            case TaskStatus.Faulted:
                // SetException will automatically wrap the original AggregateException
                // in another one. The new wrapper will be removed in TaskAwaiter, leaving
                // the original intact.
                tcs.SetException(task.Exception);
                break;
            default:
                tcs.SetException(new InvalidOperationException("Continuation called illegally."));
                break;
        }
    });

    return tcs.Task;
}

Here you can see the cleaner way of reacting to a task's status - we don't just try to fetch the result and catch any exceptions; we handle each status individually.

I don't know offhand what task scheduler is used for this continuation - it may be that we'd really want to specify the current task scheduler for a production-ready version of this code. However, the core idea is sound.

It's easy to use this extension method within an async method, as shown here:

private static async Task<int> AwaitMultipleFailures()
{
    try
    {
        await CauseMultipleFailures().WithAllExceptions();
    }
    catch (AggregateException e)
    {
        Console.WriteLine("Caught arbitrary exception: {0}", e);
        return e.InnerExceptions.Count;
    }
    // Nothing went wrong, remarkably!
    return 0;
}

private static Task<int> CauseMultipleFailures()
{
    // Simplest way of inducing multiple exceptions
    Exception[] exceptions = { new IOException(), new ArgumentException() };
    TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
    tcs.SetException(exceptions);
    return tcs.Task;
}

Note that this will work perfectly well with the Async CTP and should be fine with the full release as well. I wouldn't be entirely surprised to find something similar provided by the framework itself by release time, too.

Conclusion

It's worth being aware of the impedance mismatch between the TPL and async methods in C# 5, as well as how this mismatch is handled. I dislike the idea of data loss, but I can see why it's being handled in this way. It's very much in line with the approach of trying to make asynchronous methods look like synchronous ones as far as possible.

We'll probably look at the compositional nature of tasks again later in the series, but this was one simple example of how transparent it can be - a simple extension method can change the behaviour to avoid the risk of losing exception information when you're expecting that multiple things can go wrong.

It's worth remembering that this behaviour is very specific to Task and Task<T>, and the awaiter types associated with them. If you're awaiting other types of expressions, they may behave differently with respect to exceptions.

Before we leave the topic of exceptions, there's one other aspect we need to look at - what happens when an exception isn't observed...

Source: http://feedproxy.google.com/~r/JonSkeetCodingBlog/~3/A6N5ndsYKnw/eduasync-part-11-more-sophisticated-but-lossy-exception-handling.aspx

RF MICRO DEVICES RED HAT RADISYS

Atomicity, volatility and immutability are different, part one

I get a fair number of questions about atomicity, volatility, thread safety, immutability and the like; the questions illustrate a lot of confusion on these topics. Let's take a step back and examine each of these ideas to see what the differences are between them.

First off, what do we mean by "atomic"? From the Greek ?τομος, meaning "not divisible into smaller parts", an "atomic" operation is one which is always observed to be done or not done, but never halfway done. The C# specification clearly defines what operations are "atomic" in section 5.5. The atomic operations are reads and writes of variables of any reference type, or, effectively, any built-in value type that takes up four bytes or less, like int, short and so on. Reads and writes of variables of value types that take more than four bytes, like double, long and decimal, are not guaranteed to be atomic by the C# language.

What does it mean for a read and write of an int to be atomic?  Suppose you have static variables of type int. X is 2, Y is 1, Z is 0. Then on one thread we say:

Z = X;

and on another thread:

X = Y

Each thread does one read and one write. Each read and write is itself atomic. What is the value of Z? Without any synchronization, the threads will race. If the first thread wins then Z will be 2. If the second thread wins then Z will be 1. But Z will definitely be one of those two values, you just can't say which.

David Corbin asks in a comment to my previous entry whether immutable structs are guaranteed to be written atomically regardless of their size. The short answer is no; why would they be? Consider:

struct MyLong
{
    public readonly int low;
    public readonly int high;
    public MyLong(low, high)
    {
        this.low = low;
        this.high = high;
    }
}

Ignore for the moment the evil that is public fields. Suppose we have a fields Q, R and S of type MyLong initialized to (0x01234567, 0x0BADF00D), (0x0DEDBEEF, 0x0B0B0B0B) and (0, 0),  respectively. On two threads we say:

S = Q;

and

Q = R;

We have two threads. Each thread does one read and one write, but the reads and writes are not atomic. They can be divided! This program is actually the same as if the two threads were:

S.low = Q.low;
S.high = Q.high;

and

Q.low = R.low;
Q.high = R.high;

Now, you can't do this because that's writing to a readonly field outside a constructor. But the CLR is the one enforcing that rule; it can break it! (We'll come back to this in the next episode; things are even weirder than you might think.) Value types are copied by value; that's why they're called value types. When copying a value type, the CLR doesn't call a constructor, it just moves the bytes over one atomic chunk at a time. In practice, maybe the jitter has special registers available that allow it to move bigger chunks around, but that's not a guarantee of the C# language. The C# language only goes so far as to guarantee that the chunks are not smaller than four bytes.

Now the threads can race such that perhaps first S.low = Q.low runs, then Q.low = R.low runs, then Q.high = R.high runs, and then S.high = Q.high runs, and hey, S is now (0x0DEDBEEF, 0x0BADF00D), even though that was neither of the original values. The values have been splinched, as Hermione Granger would say (were she a computer programmer).

(And of course, the ordering above is not guaranteed either. The CLR is permitted to copy the chunks over in any order it chooses; it could be copying high before low, for example.)

The name "MyLong" was of course no accident; in effect, a two-int readonly struct is how longs are implemented on 32 bit chips. Each operation on the long is done in two parts, on each 32 bit chunk. The same goes for doubles, the same goes for anything larger than 32 bits. If you try reading and writing longs or doubles in multiple threads on 32 bit operating systems without adding some sort of locking around it to make the operation atomic, your data are highly likely to get splinched.

The only operations that are guaranteed by the C# language to be atomic without some sort of help from a lock or other synchronization magic are those listed above: individual reads and writes of variables of the right size. In particular, operations like "increment" and "decrement" are not atomic. When you say

i++;

that's a syntactic sugar for "read i, increment the read value, write the incremented value back to i". The read and write operations are guaranteed to be atomic, but the entire operation is not; it consists of multiple atomic operations and therefore is not itself atomic. Two attempts to increment i on two different threads could interleave such that one of the increments is "lost".

There are many techniques for making non-atomic operations into atomic operations; the easiest is simply to wrap every access to the variable in question with a lock, so that it is never the case that two threads are messing with the variable at the same time. You can also use the Interlocked family of helper methods which provide atomic increment, atomic compare-and-exchange, and so on.

Have a lovely Memorial Day weekend, American readers. I'm spending my Memorial Day weekend marrying a close personal friend(*). Should be fun!

Next time: readonly inside a struct is the moral equivalent of cheque kiting, plus ways you can make the atomicity guarantees stronger or weaker.

(*) Actually, I am marrying *two* close personal friends. To each other, even!

Source: http://blogs.msdn.com/b/ericlippert/archive/2011/05/26/atomicity-volatility-and-immutability-are-different-part-one.aspx

SANDISK SALESFORCE COM SAIC

Eduasync part 13: first look at coroutines with async

(This part covers project 18 in the source code.)

As I mentioned in earlier parts, the "awaiting" part of async methods is in no way limited to tasks. So long as we have a suitable GetAwaiter() method which returns a value of a type which in turn has suitable methods on it, the compiler doesn't really care what's going on. It's time to exploit that to implement some form of coroutines in C#.

Introduction to coroutines

The fundamental idea of coroutines is to have multiple methods executing cooperatively, each of them maintaining their position within the coroutine when they yield to another. You can almost think of them as executing in multiple threads, with only one thread actually running at a time, and signalling between the different threads to control flow. However, we don't really need multiple threads once we've got continuations - we can have a single thread with a complex flow of continuations, and still only a very short "real" stack. (The control flow is stored in normal collections instead of being implicit on the thread's stack.)

Coroutines were already feasible in C# through the use of iterator blocks, but the async feature of C# allows a slightly more natural way of expressing them, in my view. (The linked Wikipedia page gives a sketch of how coroutines can be built on top of generators, which in the general concept that iterator blocks implement in C#.)

I have implemented various flavours of coroutines in Eduasync. It's possible that some (all?) of them shouldn't strictly be called coroutines, but they're close enough to the real thing in feeling. This is far from an exhaustive set of approaches. Once you've got the basic idea of what I'm doing, you may well want to experiment with your own implementations.

I'm not going to claim that the use of coroutines in any of my examples really makes any sense in terms of making real tasks easier. This is purely for the sake of interest and twisting the async feature for fun.

Round-robin independent coroutines

Our first implementation of coroutines is relatively simple. A coordinator effectively "schedules" the coroutines it's set up with in a round-robin fashion: when one of the coroutines yields control to the coordinator, the coordinator remembers where the coroutine had got to, and then starts the next one. When each coroutine has executed its first piece of code and yielded control, the coordinator will go back to the first coroutine to continue execution, and so on until all coroutines have completed.

The coroutines don't know about each other, and no data is being passed between them.

Hopefully it's reasonably obvious that the coordinator contains all the smarts here - the coroutines themselves can be relatively dumb. Let's look at what the client code looks like (along with the results) before we get to the coordinator code.

Client code

The sample code contains three coroutines, all of which take a Coordinator parameter and have a void return type. These are passed to a new coordinator using a collection initializer and method group conversions; the coordinator is then started. Here's the entry point code for this:

private static void Main(string[] args)
{
    var coordinator = new Coordinator { 
        FirstCoroutine,
        SecondCoroutine,
        ThirdCoroutine
    };
    coordinator.Start();
}

When each coroutine is initially started, the coordinator passes a reference to itself as the argument to the coroutine. That's how we solve the chicken-and-egg problem of the coroutine and coordinator having to know about each other. The way a coroutine yields control is simply by awaiting the coordinator. The result type of this await expression is void - it's just a way of "pausing" the coroutine.

We're not doing anything interesting in the actual coroutines - just tracing the execution flow. Of course we could do anything we wanted, within reason. We could even await a genuinely asynchronous task such as fetching a web page asynchronously. In that case the whole coroutine collection would be "paused" until the fetch returned.

Here's the code for the first coroutine - the second and third ones are similar, but use different indentation for clarity. The third coroutine is also shorter, just for fun - it only awaits the coordinator once.

private static async void FirstCoroutine(Coordinator coordinator)
{
    Console.WriteLine("Starting FirstCoroutine");
    Console.WriteLine("Yielding from FirstCoroutine...");

    await coordinator;

    Console.WriteLine("Returned to FirstCoroutine");
    Console.WriteLine("Yielding from FirstCoroutine again...");

    await coordinator;

    Console.WriteLine("Returned to FirstCoroutine again");
    Console.WriteLine("Finished FirstCoroutine");
}

And here's the output...

Starting FirstCoroutine
Yielding from FirstCoroutine...
    Starting SecondCoroutine
    Yielding from SecondCoroutine...
        Starting ThirdCoroutine
        Yielding from ThirdCoroutine...
Returned to FirstCoroutine
Yielding from FirstCoroutine again...
    Returned to SecondCoroutine
    Yielding from SecondCoroutine again...
        Returned to ThirdCoroutine
        Finished ThirdCoroutine...
Returned to FirstCoroutine again
Finished FirstCoroutine
    Returned to SecondCoroutine again
    Finished SecondCoroutine

Hopefully that's the output you expected, given the earlier description. Again it may help if you think of the coroutines as running in separate pseudo-threads: the execution within each pseudo-thread is just linear, and the timing is controlled by our explicit "await" expressions. All of this would actually be pretty easy to implement using multiple threads which really did just block on each await expression - but the fun part is keeping it all in one real thread. Let's have a look at the coordinator.

The Coordinator class

Some of the later coroutine examples end up being slightly brainbusting, at least for me. This one is relatively straightforward though, once you've got the basic idea. All we need is a queue of actions to execute. After initialization, we want our queue to contain the coroutine starting points.

When a coroutine yields control, we just need to add the remainder of it to the end of the queue, and move on to the next item. Obviously the async infrastructure will provide "the remainder of the coroutine" as a continuation via the OnContinue method.

When a coroutine just returns, we continue with the next item in the queue as before - it's just that we won't add a continuation to the end of the queue. Eventually (well, hopefully) we'll end up with an empty queue, at which point we can stop.

Initialization and a choice of data structures

We'll represent our queue using Queue<T> where the T is a delegate type. We have two choices here though, because we have two kinds of delegate - one which takes the Coordinator as a parameter (for the initial coroutine setup) and one which has no parameters (for the continuations). Fortunately we can convert between the two in either direction very simply, bearing in mind that all of this is within the context of a coordinator. For example:

// If we're given a coroutine and want a plain Action
Action<Coordinator> coroutine = ...; 
Action action = () => coroutine(this);

// If we're given a plain Action and want an Action<Continuation>:
Action continuation = ...; 
Action<Coordinator> coroutine = ignored => continuation();

I've arbitrarily chosen to use the first option, so there's a Queue<Action> internally.

Now we need to get the collection initializer working. The C# compiler requires an appropriate Add method (which is easy) and also checks that the type implements IEnumerable. We don't really need to be able to iterate over the queue of actions, so I've use explicit interface implementation to reduce the likelihood of GetEnumerator() being called inappropriately, and made the method throw an exception for good measure. That gives us the skeleton of the class required for setting up:

public sealed class Coordinator : IEnumerable
{
    private readonly Queue<Action> actions = new Queue<Action>();

    // Used by collection initializer to specify the coroutines to run
    public void Add(Action<Coordinator> coroutine)
    {
        actions.Enqueue(() => coroutine(this));
    }

    // Required for collection initializers, but we don't really want
    // to expose anything.
    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new NotSupportedException("IEnumerable only supported to enable collection initializers");
    }
}

(Note that I haven't used XML documentation anywhere here - it's great for real code, but adds clutter in blog posts.)

For production code I'd probably prevent Add from being called after the coordinator had been started, but there's no need to do it in our well-behaved sample code. We're only going to add extra actions to the queue via continuations, which will be added due to await expressions.

The main execution loop and async infrastructure

So far we've got code to register coroutines in the queue - so now we need to execute them. Bearing in mind that the actions themselves will be responsible for adding continuations, the main loop of the coordinator is embarrassingly simple:

// Execute actions in the queue until it's empty. Actions add *more*
// actions (continuations) to the queue by awaiting this coordinator.
public void Start()
{
    while (actions.Count > 0)
    {
        actions.Dequeue().Invoke();
    }
}

Of course, the interesting bit is the code which supports the async methods and await expressions. We know we need to provide a GetAwaiter() method, but what should that return? Well, we're just going to use the awaiter to add a continuation to the coordinator's queue. It's got no other state than that - so we might as well return the coordinator itself, and put the other infrastructure methods directly in the coordinator.

Again, this is slightly ugly, as the extra methods don't really make sense on the coordinator - we wouldn't want to call them directly from client code, for example. However, they're fairly irrelevant - we could always create a nested type which just had a reference to its "parent" coordinator if we wanted to. For simplicity, I haven't bothered with this - I've just implemented GetAwaiter() trivially:

// Used by await expressions to get an awaiter
public Coordinator GetAwaiter()
{
    return this;
}

So, that leaves just three members still to implement: IsCompleted, OnCompleted and GetResult. We always want the IsCompleted property to return false, as otherwise the coroutine will just continue executing immediately without returning to cede control; the await expression would be pointless. OnCompleted just needs to add the continuation to the end of the queue - we don't need to attach it to a task, or anything like that. Finally, GetResult is a no-op - we have no results, no exceptions, and basically nothing to do. You might want to add a bit of logging here, if you were so inclined, but there's no real need.

So, here are the final three members of Coordinator:

// Force await to yield control
public bool IsCompleted { get { return false; } }

public void OnCompleted(Action continuation)
{
    // Put the continuation at the end of the queue, ready to
    // execute when the other coroutines have had a go.
    actions.Enqueue(continuation);
}

public void GetResult()
{
    // Our await expressions are void, and we never need to throw
    // an exception, so this is a no-op.
}

And that's it! Fewer than 50 lines of code required, and nothing complicated at all. The interesting behaviour is all due to the way the C# compiler uses the coordinator when awaiting it.

We need AsyncVoidMethodBuilder as before, as we have some async void methods - but that doesn't need to do anything significant. That's basically all the code required to implement these basic round-robin coroutines.

Conclusion

Our first foray into the weird and wonderful world of coroutines was relatively tame. The basic idea of a coordinator keeping track of the state of all the different coroutines in one sense or another will keep coming back to us, but with different ways of controlling the execution flow.

Next time we'll see some coroutines which can pass data to each other.

Source: http://feedproxy.google.com/~r/JonSkeetCodingBlog/~3/TRwK6BPlGqE/eduasync-part-13-first-look-at-coroutines-with-async.aspx

LSI LINEAR TECHNOLOGY LEXMARK INTERNATIONAL

localhost redirecting to www.localhost.com

Source: http://yacoding.blogspot.com/2008/07/localhost-redirecting-to.html

NATIONAL INSTRUMENTS MOTOROLA MOODYS

Introducing Marble Touch

It’s release preparation time again. As most features are fixed by now, this is a good time to show some of the things we’ve been working on lately. There were a couple of blogs about Marble features that will debut in KDE 4.8 / Marble 1.3 already, but I’d like to introduce another one which we didn’t announce properly yet: Marble Touch, a Qt Quick Components based version of Marble built for the Nokia N9/N950. It is centered around different views or activities that align the user interface for common tasks like searching or routing.

The first version is planned for release in about two months. Like all Marble programs it’s based on the Marble library to reuse the vast amount of features it offers. Marble Touch 1.3.0 will come with the following activities: Virtual Globe, Search, Routing, Tracking, Weather, Friends, Space View. See the current state in the Youtube video Marble Touch on the Nokia N950.

You may notice certain glitches in the video — missing icons, missing animations, missing pinch zoom, z-order problems, slow response time. That’s alright for the beta state and we’ll take care of as much as possible until the release. I’d love to see help from a designer or usability person though! If you’re interested, please visit #marble in Freenode or write to marble-devel@kde.org.

After the first release there’ll be feature releases every month. They’ll add features that are currently implemented in the Marble library, but not yet available from the Marble Touch user interface: Bookmark support, guidance mode, voice navigation. In parallel I’d like to work on an Android version of Marble Touch optimized for tablets. A Plasma Active version would be nice as well, but I lack the hardware to play with it.

 

Source: http://nienhueser.de/blog/?p=352

NOVELL NETWORK APPLIANCE NETGEAR

Nobody's Going to Help You, and That's Awesome

I'm not into self-help. I don't buy self-help books, I don't read productivity blogs, and I certainly don't subscribe to self-proclaimed self-help guru newsletters. Reading someone else's advice on the rather generic concept of helping yourself always struck me as a particularly misguided idea.

Apparently I'm not the only person to reach this conclusion, either.

I spent two years reading all the self-help books I could find. As of a year ago, I had read 340 self-help books. Because I?m insane.

My conclusion from all that reading?

95% of self-help books are complete bullshit.

To be clear, I am all for self-improvement. Reading books, blogs, and newsletters by people who have accomplished great things is a fine way to research your own path in life. But these people, however famous and important they may be, are not going to help you.

Unfortunately that's not the answer he wanted. To him, my answer [that nobody was going to help him become successful] was really discouraging. To me, if I was receiving that answer from someone else, it would be really encouraging.

I like being reminded that nobody's going to help me - that it's all up to me. It puts my focus back on the things I can control - not waiting for outside circumstances.

Take it from The Ultimate Productivity Blog:

Reading self-help advice from other people, however well-intentioned, is no substitute for getting your own damn work done. The sooner you come to terms with this, the better off you'll be.

Get out there and do stuff because you fundamentally enjoy it and because it makes you better. As a writer, as an analyst, as a techie, whatever. Learn to love practicing the fundamentals and do it better each time. Over time, quality does lead to success, but you have to be patient. Really patient. Turns out, "overnight" success takes years. Maybe even decades. This is not a sprint, it's a marathon. Plan accordingly.

For example, I don't care if anyone reads what I write here. I'm writing to satisfy myself first and foremost. If others read it and benefit from it, fantastic -- that's a welcome side effect. If I worry about who is reading, why they're reading, or if anyone is even reading at all, I'd be too paralyzed to write! That'd be the least productive outcome of all.

That's not to say that some introspection about the nature of your work isn't useful. It is. Even the weary self-help student I quoted above concluded that 5% of self-help advice surprisingly wasn't bullshit. The one book he recommended without hesitation? 59 Seconds: Think a Little, Change a Lot.

Despite my deep reservations about the genre, I ordered this book based on his recommendation and a number of credible references to it I noticed on the Skeptic Stack Exchange.

Why does this self-help book work when so many others fail? In a word, science! The author goes out of his way to find actual published scientific research documenting specific ways we can make small changes in our behavior to produce better outcomes for ourselves and those around us. It's powerful stuff, and the book is full of great, research backed insights like this one:

A group of participants were asked to select a negative experience. One group of participants were then asked to have a long chat with a supportive experimenter about the event, while a second group were invited to chat about a far more mundane topic - a typical day.

Participants who had spent time talking about their traumatic event thought the chat had been helpful. However, the various questionnaires told a very different story. In reality the chat had no significant impact at all. They might just as well have been chatting about a typical day.

In several studies, participants who have experienced a traumatic event have been encouraged to spend just a few minutes each day writing in a diary-type account of their deepest thoughts and feelings about it. For example, in one study participants who had just been made redundant were asked to reflect upon their deepest thoughts and feelings about their job loss, including how it had affected both their personal and professional lives. Although these types of exercises were both speedy and simple, the results revealed a remarkable boost in their psychological and physical well-being, including a reduction in health problems and an increase in self-esteem and happiness.

The results left psychologists with something of a mystery. Why would talking about a traumatic experience have almost no effect but writing about it yield such significant benefits? From a psychological perspective, talking and writing are very different. Talking can often be somewhat unstructured, disorganized, even chaotic. In contrast, writing encourages the creation of a story line and structure that help people make sense of what has happened and work towards a solution. In short, talking can add to a sense of confusion, but writing provides a more systematic, solution-based approach.

Therefore, the real world change you would make based on this advice – the proverbial 59 seconds on the book jacket – is to avoid talking through traumatic experiences in favor of writing about them. Not because some self-help guru said so, but because the published research data tells us that talking doesn't work and writing does. Not exactly intuitive, since talking through our problems with a friend always feels like the right thing to do, but I have certainly documented many times over the value of writing through a problem.

59 Seconds is so good, in fact, it has rekindled my hopes that our new Stack Exchange Productivity Q&A can work. I'd love for our productivity site to be founded on a scientific basis, and not the blind cult of personality I've come to expect from the self-help industry.

Remember, nobody's going to help you … except science, and if you're willing to put in the required elbow grease each and every day – yourself.

Source: http://www.codinghorror.com/blog/2011/07/nobodys-going-to-help-you-and-thats-awesome.html

MISCROSOFT OFFICE MICROSOFT MCAFEE

iOS Developers, We Are Hiring!

ELC Technologies is hiring! At ELC we are proud of more than 100 years of combined application development experience including dynamic languages like Ruby, JRuby, Python, as well as strongly typed languages such as C and Java. Our knowledge of the Cloud lets us build true scalability into products. This experience, coupled with our creativity, has led us to build some of the largest, most used apps out there. We are experts in AGILE development, delivering working software in weeks, not ...

Source: http://feedproxy.google.com/~r/icodeblog/~3/gB2v8HNuyBI/

LINEAR TECHNOLOGY LEXMARK INTERNATIONAL LEVEL 3 COMMUNICATIONS

Plasma NM 0.8.98

Plasma NM 0.8.98 (AKA 0.9.0_rc3) is now available.

MD5Sum: e730805567a771506cb18c0a825738ef
SHA1Sum: f46274c4cca722f37eef7418144c0c04bfe21e24

Changelog:


286855: Refuses to create VPNC connections without user or group info since vpnc-0.5.3 refuses to connect without them.
287531: Add some checks to prevent crash when PolicyKit denies connection editing.
287076: Report error message on VPN activation failure.
285637: Fix icons for bluetooth interface item and system tray (when the bluetooth interface is the default interface).
286424: Try to prevent gsm connection access technology change from freezing plasma-desktop for a few seconds.
285637: Fix creation of NAP/PAN bluetooth connections.
286856: Show user and group names in vpnc authentication dialog.
283204: Set Bluetooth DUN's passwords as AgentOwned by default.
286666: Do not reset username and password fields when changing Dynamic WEP's authentication method.
. Always asks secrets from user if NM requested new secrets.
286243: prevent crash when resuming from RAM.
283241: fix random crash.
. Add check for minimum openconnect version required (3.03).


The following languages have more than 80% of the strings translated:

ca cs da de el hr it lt nb nds nl pt pt_BR ro ru sv uk zh_CN zh_TW

Source: http://lamarque-lvs.blogspot.com/2011/11/plasma-nm-0898.html

KEY JDS UNIPHASE JDA SOFTWARE GROUP

How to Use Constructors and Do Inheritance Properly in JavaScript

Source: http://my2iu.blogspot.com/2011/05/how-to-use-constructors-and-do.html

TIBCO SOFTWARE TIBCO SOFTWARE THQ

Eduasync part 11: More sophisticated (but lossy) exception handling

(This post covers projects 13-15 in the source code.)

Long-time readers of this blog may not learn much from this post - it's mostly going over what I've covered before. Still, it's new to Eduasync.

Why isn't my exception being caught properly?

Exceptions are inherently problematic in C# 5. There are two conflicting aspects:

• The point of the async feature in C# 5 is that you can write code which mostly looks like its synchronous code. We expect to be able to catch specific exception types as normal.
• Asynchronous code may potentially have multiple exceptions "at the same time". The language simply isn't designed to deal with that in the synchronous case.

Now if the language had been designed for asynchrony to start with, perhaps exception flow would have been designed differently - but we are where we are, and we all expect exceptions to work in a certain way.

Let's make all of this concrete with a sample:

private static void Main(string[] args)
{
    Task<int> task = FetchOrDefaultAsync();
    Console.WriteLine("Result: {0}", task.Result);
}

private static async Task<int> FetchOrDefaultAsync()
{
    // Nothing special about IOException here
    try
    {
        Task<int> fetcher = Task<int>.Factory.StartNew(() => { throw new IOException(); });
        return await fetcher;
    }
    catch (IOException e)
    {
        Console.WriteLine("Caught IOException: {0}", e);
        return 5;
    }
    catch (Exception e)
    {
        Console.WriteLine("Caught arbitrary exception: {0}", e);
        return 10;
    }
}

Here we have a task which will throw an IOException, and some code which awaits that task - and has a catch block for IOException.

So, what would you expect this to print? With the code we've got in Eduasync so far, we get this:

Caught arbitrary exception: System.AggregateException: One or more errors occurred. ---> System.IO.IOException: I/O error occurred.
...
Result: 10

If you run the same code against the async CTP, you get this:

Caught IOException: System.IO.IOException: I/O error occurred.
...
Result: 5

Hmm... we're not behaving as per the CTP, and we're not behaving as we'd really expect the normal synchronous code to behave.

The first thing to work out is which boundary we should be fixing. In this case, the problem is between the async method and the task we're awaiting, so the code we need to fix is TaskAwaiter<T>.

Handling AggregateException in TaskAwaiter<T>

Before we can fix it, we need to work out what's going on. The stack trace I hid before actually show this reasonably clearly, with this section:

at System.Threading.Tasks.Task.ThrowIfExceptional(Boolean includeTaskCanceled Exceptions)
at System.Threading.Tasks.Task`1.get_Result()
at Eduasync.TaskAwaiter`1.GetResult() ...\TaskAwaiter.cs:line 40
at Eduasync.Program.<FetchOrDefaultAsync>d__2.MoveNext() ...\Program.cs:line 37

So AggregateException is being thrown by Task<T>.Result, which we're calling from TaskAwaiter<T>.GetResult(). The documentation for Task<T>.Result isn't actually terribly revealing here, but the fact that Task<T>.Exception is of type AggregateException is fairly revealing.

Basically, the Task Parallel Library is built with the idea of multiple exceptions in mind - whereas our async method isn't.

Now the team in Microsoft could have decided that really you should catch AggregateException and iterate over all the exceptions contained inside the exception, handling each of them separately. However, in most cases that isn't really practical - because in most cases there will only be one exception (if any) and all that looping is relatively painful. They decided to simply extract the first exception from the AggregateException within a task, and throw that instead.

We can do that ourselves in TaskAwaiter<T>, like this:

try
{
    return task.Result;
}
catch (AggregateException aggregate)
{
    if (aggregate.InnerExceptions.Count > 0)
    {
        // Loses the proper stack trace. Oops. For workarounds, see
        // See http://bradwilson.typepad.com/blog/2008/04/small-decisions.html
        throw aggregate.InnerExceptions[0];
    }
    else
    {
        // Nothing better to do, really...
        throw;
    }
}

As you can tell from the comment, we end up losing the stack trace using this code. I don't know exactly how the stack trace is preserved in the real Async CTP, but it is. I suspect this is done in a relatively obscure way at the moment - it's possible that for .NET 5, there'll be a cleaner way that all code can take advantage of.

This code is also pretty ugly, catching the exception only to rethrow it. We can check whether or not the task has faulted using Task<T>.Status and extract the AggregateException using Task<T>.Exception instead of forcing it to be thrown and catching it. We'll see an example of that in a minute.

With our new code in place, we can catch the IOException in our async code very easily.

What if I want all the exceptions?

In certain circumstances it really makes sense to collect multiple exceptions. This is particularly true when you're waiting for multiple tasks to complete, e.g. with TaskEx.WhenAll in the Async CTP. This caused me a certain amount of concern for a while, but when Mads came to visit in late 2010 and we talked it over, we realized we could use the compositional nature of Task<T> and the convenience of TaskCompletionSource to implement an extension method preserving all the exceptions.

As we've seen, when a task is awaited, its AggregateException is unwrapped, and the first exception rethrown. So if we create a new task which adds an extra layer of wrapping and make our code await that instead, only the extra layer will be unwrapped by the task awaiter, leaving the original AggregateException. To come up with a new task which "looks like" an existing task, we can simply create a TaskCompletionSource, add a continuation to the original task, and return the completion source's task as the wrapper. When the continuation fires we'll set the appropriate result on the completion source - cancellation, an exception, or the successful result.

You may expect that we'd have to create a new AggregateException ourselves - but TaskCompletionSource.SetException will already do this for us. This makes it looks like the code below isn't performing any wrapping at all, but remember that Task<T>.Exception is already an AggregateException, and calling TaskCompletionSource.SetException will wrap it in another AggregateException. Here's the extension method in question:

public static Task<T> WithAllExceptions<T>(this Task<T> task)
{
    TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();

    task.ContinueWith(ignored =>
    {
        switch (task.Status)
        {
            case TaskStatus.Canceled:
                tcs.SetCanceled();
                break;
            case TaskStatus.RanToCompletion:
                tcs.SetResult(task.Result);
                break;
            case TaskStatus.Faulted:
                // SetException will automatically wrap the original AggregateException
                // in another one. The new wrapper will be removed in TaskAwaiter, leaving
                // the original intact.
                tcs.SetException(task.Exception);
                break;
            default:
                tcs.SetException(new InvalidOperationException("Continuation called illegally."));
                break;
        }
    });

    return tcs.Task;
}

Here you can see the cleaner way of reacting to a task's status - we don't just try to fetch the result and catch any exceptions; we handle each status individually.

I don't know offhand what task scheduler is used for this continuation - it may be that we'd really want to specify the current task scheduler for a production-ready version of this code. However, the core idea is sound.

It's easy to use this extension method within an async method, as shown here:

private static async Task<int> AwaitMultipleFailures()
{
    try
    {
        await CauseMultipleFailures().WithAllExceptions();
    }
    catch (AggregateException e)
    {
        Console.WriteLine("Caught arbitrary exception: {0}", e);
        return e.InnerExceptions.Count;
    }
    // Nothing went wrong, remarkably!
    return 0;
}

private static Task<int> CauseMultipleFailures()
{
    // Simplest way of inducing multiple exceptions
    Exception[] exceptions = { new IOException(), new ArgumentException() };
    TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
    tcs.SetException(exceptions);
    return tcs.Task;
}

Note that this will work perfectly well with the Async CTP and should be fine with the full release as well. I wouldn't be entirely surprised to find something similar provided by the framework itself by release time, too.

Conclusion

It's worth being aware of the impedance mismatch between the TPL and async methods in C# 5, as well as how this mismatch is handled. I dislike the idea of data loss, but I can see why it's being handled in this way. It's very much in line with the approach of trying to make asynchronous methods look like synchronous ones as far as possible.

We'll probably look at the compositional nature of tasks again later in the series, but this was one simple example of how transparent it can be - a simple extension method can change the behaviour to avoid the risk of losing exception information when you're expecting that multiple things can go wrong.

It's worth remembering that this behaviour is very specific to Task and Task<T>, and the awaiter types associated with them. If you're awaiting other types of expressions, they may behave differently with respect to exceptions.

Before we leave the topic of exceptions, there's one other aspect we need to look at - what happens when an exception isn't observed...

Source: http://feedproxy.google.com/~r/JonSkeetCodingBlog/~3/A6N5ndsYKnw/eduasync-part-11-more-sophisticated-but-lossy-exception-handling.aspx

LAM RESEARCH L1 IDENTITY SOLUTIONS KINGSTON TECHNOLOGY COMPANY

Eduasync part 17: unit testing

In the last post I showed a method to implement "majority voting" for tasks, allowing a result to become available as soon as possible. At the end, I mentioned that I was reasonably confident that it worked because of the unit tests... but I didn't show the tests themselves. I felt they deserved their own post, as there's a bigger point here: it's possible to unit test async code. At least sometimes.

Testing code involving asynchrony is generally a pain. Introducing the exact order of events that you want is awkward, as is managing the threading within tests. With a few benefits with async methods:

• We know that the async method itself will only execute in a single thread at a time
• We can control the thread in which the async method will execute, if it doesn't configure its awaits explicitly
• Assuming the async method returns Task or Task<T>, we can check whether or not it's finished
• Between Task<T> and TaskCompletionSource<T>, we have a way of injecting tasks that we understand

Now in our sample method we have the benefit of passing in the tasks that will be awaited - but assuming you're using some reasonably testable API to fetch any awaitables within your async method, you should be okay. (Admittedly in the current .NET framework that excludes rather a lot of classes... but the synchronous versions of those calls are also generally hard to test too.)

The plan

For our majority tests, we want to be able to see what happens in various scenarios, with tasks completing at different times and in different ways. Looking at the test cases I've implemented I have the following tests:

• NullSequenceOfTasks
• EmptySequenceOfTasks
• NullReferencesWithinSequence
• SimpleSuccess
• InputOrderIsIrrelevant
• MajorityWithSomeDisagreement
• MajorityWithFailureTask
• EarlyFailure
• NoMajority

I'm not going to claim this is a comprehensive set of possible tests - it's a proof of concept more than anything else. Let's take one test as an example: MajorityWithFailureTask. The aim of this is to pass three tasks (of type Task<string>) into the method. One will give a result of "x", the second will fail with an exception, and the third will also give a result of "x". The events will occur in that order, and only when all three results are in should the returned task complete, at which point it will also have a success result of "x".

So, the tricky bit (compared with normal testing) is introducing the timing. We want to make it appear as if tasks are completing in a particular order, at predetermined times, so we can check the state of the result between events.

Introducing the TimeMachine class

Okay, so it's a silly name. But the basic idea is to have something to control the logical flow of time through our test. We're going to ask the TimeMachine to provide us with tasks which will act in a particular way at a given time, and then when we've started our async method we can then ask it to move time forward, letting the tasks complete as they go. It's probably best to look at the code for MajorityWithFailureTask first, and then see what the implementation of TimeMachine looks like. Here's the test:

[Test]
public void MajorityWithFailureTask()
{
    var timeMachine = new TimeMachine();
    // Second task gives a different result
    var task1 = timeMachine.AddSuccessTask(1, "x");
    var task2 = timeMachine.AddFaultingTask<string>(2, new Exception("Bang!"));
    var task3 = timeMachine.AddSuccessTask(3, "x");

    var resultTask = MoreTaskEx.WhenMajority(task1, task2, task3);
    Assert.IsFalse(resultTask.IsCompleted);

    // Only one result so far - no consensus
    timeMachine.AdvanceTo(1);
    Assert.IsFalse(resultTask.IsCompleted);

    // Second result is a failure
    timeMachine.AdvanceTo(2);
    Assert.IsFalse(resultTask.IsCompleted);

    // Third result gives majority verdict
    timeMachine.AdvanceTo(3);
    Assert.AreEqual(TaskStatus.RanToCompletion, resultTask.Status);
    Assert.AreEqual("x", resultTask.Result);
}

As you can see, there are two types of method:

• AddSuccessTask / AddFaultingTask / AddCancelTask (not used here) - these all take the time at which they're going to complete as their first parameter, and the method name describes the state they'll reach on completion. The methods return the task created by the time machine, ready to pass into the production code we're testing.
• AdvanceTo / AdvanceBy (not used here) - make the time machine "advance time", completing pre-programmed tasks as it goes. When those tasks complete, any continuations attached to them also execute, which is how the whole thing hangs together.

Now forcing tasks to complete is actually pretty simple, if you build them out of TaskCompletionSource<T> to start with. So all we need to do is keep our tasks in "time" order (which I achieve with SortedList), and then when we're asked to advance time we move through the list and take the appropriate action for all the tasks which weren't completed before, but are now. I represent the "appropriate action" as a simple Action, which is built with a lambda expression from each of the Add methods. It's really simple:

public class TimeMachine
{
    private int currentTime = 0;
    private readonly SortedList<int, Action> actions = new SortedList<int, Action>();

    public int CurrentTime { get { return currentTime; } }

    public void AdvanceBy(int time)
    {
        AdvanceTo(currentTime + time);
    }

    public void AdvanceTo(int time)
    {
        // Okay, not terribly efficient, but it's simple.
        foreach (var entry in actions)
        {
            if (entry.Key > currentTime && entry.Key <= time)
            {
                entry.Value();
            }
        }
        currentTime = time;
    }

    public Task<T> AddSuccessTask<T>(int time, T result)
    {
        TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
        actions[time] = () => tcs.SetResult(result);
        return tcs.Task;
    }

    public Task<T> AddCancelTask<T>(int time)
    {
        TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
        actions[time] = () => tcs.SetCanceled();
        return tcs.Task;
    }

    public Task<T> AddFaultingTask<T>(int time, Exception e)
    {
        TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
        actions[time] = () => tcs.SetException(e);
        return tcs.Task;
    }
}

Okay, that's a fair amount of code for a blog posts (and yes, it could do with some doc comments etc!) but considering that it makes life testable, it's pretty simple.

So, is that it?

It works on my machine... with my test runner... in simple cases...

When I first ran the tests using TimeMachine, they worked almost immediately. This didn't surprise me nearly as much as it should have done. You see, when the tests execute, they use async/await in the normal way - which means the continuations are scheduled on "the current task scheduler". I have no idea what the current task scheduler is in unit tests. Or rather, it feels like something which is implementation specific. It could easily have worked when running the tests from ReSharper, but not from NCrunch, or not from the command line NUnit test runner.

As it happens, I believe all of these run tests on thread pool threads with no task scheduler allocated, which means that the continuation is attached to the task to complete "in-line" - so when the TimeMachine sets the result on a TaskCompletionSource, the continuations execute before that call returns. That means everything happens on one thread, with no ambiguity or flakiness - yay!

However, there are two problems:

• The words "I believe" aren't exactly confidence-inspiring when it comes to testing that your software works correctly.
• Our majority voting code only ever sees one completed task at a time - we're not testing the situation where several tasks complete so quickly together that the continuation doesn't get chance to run before they've all finished.

Both of these are solvable with a custom TaskScheduler or SynchronizationContext. Without diving into the docs, I'm not sure yet which I'll need, but the aim will be:

• Make TimeMachine implement IDisposable
• In the constructor, set the current SynchronizationContext (or TaskScheduler) to a custom one having remembered what the previous one was
• On disposal, reset the context
• Make the custom scheduler keep a queue of jobs, such that when we're asked to advance to time T, we complete all the appropriate tasks but don't execute any continuations, then we execute all the pending continuations.

I don't yet know how hard it will be, but hopefully the Parallel Extensions Samples will help me.

Conclusion

I'm not going to claim this is "the" way of unit testing asynchronous methods. It's clearly a proof-of-concept implementation of what can only be called a "test framework" in the loosest possible sense. However, I hope it gives an example of a path we might take. I'm looking forward to seeing what others come up with, along with rather more polished implementations.

Next time, I'm going to shamelessly steal an idea that a reader mailed me (with permission, of course). It's insanely cool, simple and yet slightly brain-bending, and I suspect will handy in many situations. Love it.

Source: http://feedproxy.google.com/~r/JonSkeetCodingBlog/~3/DnRbqgbMyKE/eduasync-part-17-unit-testing.aspx

UNISYS TRIQUINT SEMICONDUCTOR TRIMBLE NAVIGATION LIMITED

Following the pattern

Here's a question I got from a user recently:

The foreach loop in C# uses a pattern-based approach to semantic analysis. LINQ in C# also uses a pattern-based approach. Why don't other features, such as the "using" statement, also use a pattern-based approach?

What a great question!

First off, what do we mean by a "pattern-based approach"?

You might think that in order to use a foreach loop, the collection you are iterating over must implement IEnumerable or IEnumerable<T>. But as it turns out, that is not actually a requirement. What is required is that the type of the collection must have a public method called GetEnumerator, and that must return some type that has a public property getter called Current and a public method MoveNext that returns a bool. If the compiler can determine that all of those requirements are met then the code is generated to use those methods. Only if those requirements are not met do we check to see if the object implements IEnumerable or IEnumerable<T>.

Essentially, C# is doing a fairly strong form of "duck typing" here. That is, if the object is known at compile time to have a Quack() method then we treat it like a duck even if it isn't marked as implementing IDuck. There are a few places in the C# language where we do this sort of "pattern matching"; we don't care what the exact type is, just so long as the methods we need are available.

But why do we use a pattern-based approach in foreach in the first place?

Two reasons. First, imagine a world without generic types: the world of C# 1.0. Suppose you have a collection that you yourself have just implemented, a collection of ten square integers:

class MyIntegers : IEnumerable
{
  private class MyEnumerator : IEnumerator
  {
    private int index = 0;
    public object Current { return index * index; }
    public bool MoveNext()
    {
      if (index > 10) return false;
      ++index;
      return true;
    }
  }
  public IEnumerator GetEnumerator() { return new MyEnumerator(); }
}

When you "foreach" over this thing, every integer that comes out of the collection is boxed. How can you avoid the boxing penalty? Like this:

class MyIntegers : IEnumerable
{
  public class MyEnumerator : IEnumerator
  {
    private int index = 0;
    object IEnumerator.Current { return this.Current; }
    int Current { return index * index; }
    public bool MoveNext()
    {
      if (index > 10) return false;
      ++index;
      return true;
    }
  }
  public MyEnumerator GetEnumerator() { return new MyEnumerator(); }
  IEnumerator IEnumerable.GetEnumerator() { return this.GetEnumerator(); }
}

Now the foreach loop sees can use the public method GetEnumerator that returns a MyEnumerator, that in turn has a public property Current that returns an int. No boxing required.

The second reason is because using this approach, the "MyEnumerator" could also be a mutable struct. Yes, mutable structs are a bad programming practice, but in this case it's not so bad because the "foreach" loop is never going to expose the raw enumerator to possible misuse by user code. Sometimes you really do want to avoid collection pressure, so making the enumerator a struct can be a small but measurable win. (As always, do not make things into structs "because they are faster" unless you have empirical evidence that doing so makes a measurable and important difference.)

So there you go: we use a pattern-based approach for "foreach" because first, we didn't have the ability to avoid boxing via IEnumerable<T> in C# 1.0, and because there is a small but perhaps important performance win in avoiding the pressure of allocating a reference-typed enumerator.

What about LINQ? We also use a pattern-based approach in LINQ. When you say "from c in customers where ..." we do not require that "customers" have a "Where" method, or even that it implement IEnumerable. We don't have any type requirements on it at all; rather, we require that overload resolution finds an instance method or an extension method called "Where" that works with the LINQ pattern.

Again, two reasons. The first reason is that LINQ was invented very late; it would not be a success if we required everyone who wanted to have their data source work with LINQ have to ship a new version of their interface that has Where and Select methods. It has to be a feature that "lights up" without any work on behalf of the data source providers.

The second and more highfalutin reason is that LINQ was designed to bake the "monad" pattern into C#. It was specifically designed to bake in the "sequence" monad, but if you are a crazy person you can actually use query comprehension syntax to represent binding operations on any monad, as Wes points out in his excellent article. People sometimes ask why there is no "IMonad" interface in C# that identifies a type that can be used as a monad. The short answer is that the concept of "I am a type that obeys the rules of a monad" is actually too general for the .NET type system to handle; the monad pattern is a "higher type" than an interface. Therefore, rather than bake it into the type system, we baked it into the compiler. (*)

So now we come to the user's actual question: given that we use this pattern-based approach in several places in C#, why not use it everywhere? Why require that an object implement IDisposable to be disposed in a "using" block? Why not just require that it implement a public method called Dispose?

The answer is that we like capturing things in type systems; we do so whenever we can. Types are our first and best solution for solving problems in a statically-analyzed language, and so we want to stick to that whenever possible. In the case of the "using" block there is no compelling reason to not require that a disposable object mark itself with a special interface. We've already seen that we can elide boxing in things that get disposed, and even if we cannot, the boxing penalty is pretty small for disposing a dozen handle-holding objects compared to the penalty of boxing a million integers coming out of a collection. And the LINQ reasoning doesn't apply to "using" -- we do not want you to be able to extend the disposal behaviour of objects you do not own, even as we do want you to be able to extend the sorting, searching and grouping behaviours of objects you do not own. With no compelling reason for a pattern-based approach, and no compelling reason against an interface-based approach, we went with the interface.

However, as the C# language gets more and more high-level features added to it, we are finding that often a pattern-based approach is necessary. The coming "async/await" feature, for example, will use a LINQ-like pattern-based approach to figuring out how to make an "awaiter" for a particular "task" object. Pattern-based approaches can allow more participation by third parties and enable language designers to embed design patterns in the language that are too rich for their type systems to handle, so I would expect to see more of this sort of thing in the future.

--------------------

(*) A detailed explanation of why the .NET type system is insufficient to represent higher types would take us pretty far afield. If this subject interests you, see this StackOverflow question. For more ideas on how the generic type system of .NET is insufficient to represent certain desired patterns, see my recent article on the subject. If you want an even more gentle introduction to monads than Wes's article, see this StackOverflow question.

Source: http://blogs.msdn.com/b/ericlippert/archive/2011/06/30/following-the-pattern.aspx

XILINX WESTERN DIGITAL VOLT INFORMATION SCIENCES

Working inside a Virtual Machine

Source: http://yacoding.blogspot.com/2007/09/working-inside-virtual-machine.html

NATIONAL INSTRUMENTS MOTOROLA MOODYS