Part A)

The Application object is needed in ASP.NET so different Pages in different
Sessions can share data. Page cannot be used for this purpose because it is
stateless. Session also cannot because it is specific to an individual
session, each user has their own copy. Static fields could potentially be
used for shared data, however, that would mean there could only be one
"Instance" of an application on the server. By using a shared Application
object we can have many different application instances that share the same
code but have different shared data.

Session doesn't make sense for a web service. Method calls to web services
are stateless. Most of the time the HTTP client at the other end won't even
be capable of storing the cookies required for the sessionid anyway.

By making WebMethod asynchronous the web server can run the method in a
separare thread and free up its thread to do more work. Less time is spent
blocked in a web server thread.

Calling a web service asynchronously has similar advantages on the client
side. The client is free to do other work while the web service processes
the request. This can be very important for GUI programming where you don't
want to block the event handling thread.

Morse sometimes returns an extra newline because a thread could finish
(leadng to the nRandy == 1 case) before all the threads have been started
(which would lead to another nRandy == 1 case)

http://msdn2.microsoft.com/en-us/library/676s4xab(en-US,VS.80).aspx

"if e then s1 else s2" evaluates an expression (e) and then dispatches to
one of two statements (s1 for true, s2 for false) based on the boolean
value of e.

"switch(e) { case c1: s1; break; case c2: s2; break; default: s3; break"
evaluates an expression (e) and then dispatches to one of many statements
based on the integral value of e. if e = c1 then s1 is executed, if e = c2
then s2 is executed, etc. If none match the default case (s3) is executed.

"e1 ? e2 : e3" evaluates an expression e1 then return the value of either
expression e2 (if e1 was true) or e3 (if e1 was false).

http://msdn2.microsoft.com/en-us/library/6tcf2h8w(en-US,VS.80).aspx

The "new" modifier makes this method and a completelly new and unrelated
method to the method that would normally be inherited from the base class.
Making a method in a subclass "new" then calling the method it overrides in
the base class will still call the base class method.

The "override" modifier makes this method override the one in the base
class. Even calling this method on the base class itself will call this
method.

"virtual" marks a method in a base class able to be overridden with
"override". This is kind of like the opposite of final in java.

"abstract" marks a method that has no implementation in the base class and
MUST be overridden in subclasses. You cannot instansiate classes with
abstract methods.