small_space_chart, originally uploaded by bill.knapp.

Meegan Lillis and I presented on this topic at the Campus Technology 09 conference this past summer in Boston. The idea was to visually represent the concept of using instructional technology (in this case web 2.0) to bridge time and space. The space continuum along the left side of the poster illustrates the use of increasingly complex solutions which allow students and instructors to meet synchronously from simple chat to web-conferencing and virtual worlds. The time continuum looks at connecting asynchronously using technologies which support increasing the distance, beginning with campus infrastructure and moving to G3/G4 wireless and hand-held solutions.

Yesterday, I tried helping a faculty connect his class here on campus with another class at a high school several hundred miles away. Their plan was to discuss issues of diversity using a combination of teleconferencing and web-conferencing solutions. The arrangements had been made ahead of time and the faculty on my end had been trying to complete the connections since early in the day.

However when the time came for class to begin there were problems getting it to work as planned. The HS teacher lacked experience setting up the conference phone and was unable to connect. I then shared the URL for the web-conference with the remote instructor in hopes that they might be able at least to use the chat feature to ask and respond to questions. But they were apparently unable to log on and the class went by without any connections being made.

The technology we attempted to use for the project was not especially new or complicated and had been used successfully many times before, but this time it failed. Will these educators try it again, or simply dismiss it as something that does’t work?

I wonder how many times people decide to implement technology solutions with every expectation that all they need do is plug it in or turn it on, only to discover that it doesn’t work as expected. I would guess a fair percentage of the time. Whether our expectations are met the first time we use a technology directly influences our perception of the quality or appropriateness of a given solution. Perfectly good solutions are discarded when they don’t work as expected the very first time – even when our own lack of experience is the cause of the failure.

As instructional technologists I believe an important part of our work is preparing faculty and students to know what to expect. The truth is that most of the time the technology they select will require some configuration and isn’t exactly what you might call “plug-n-play”. When it comes to best practices, a practice session is always a good idea; if others are to be included from a distance testing the service ahead of time will go a long way toward a successful and satisfying experience.

Concurrency is one of those terms that everyone has an intuition about its definition until needs to write about it, realizing that the concept is too open to just use “concurrency”.

Follows the first phrase in Wikipedia’s entry for “Concurrency”:

In computer science, concurrency is a property of systems in which several computations are executing simultaneously, and potentially interacting with each other.

By using the words simultaneously and interacting, this definition captures (for me) the essence of concurrency.

One of the fundamental properties of concurrent systems is their execution model, that is, when should the concurrent computations (I’ll call them concurrent entities) in the system run, and what are the rules that an entity should obey while running.

• Asynchronous Concurrency

In asynchronous execution, entities are in charge of their own control flow and execute independently of each other. Hence, each entity has its own notion of time, not shared globally. The decision to synchronize with other parts of the system is also internal to each entity, and not enforced by the surrounding environment. Depending on the concurrency model in use, these entities are known as threads, actors, processes, tasks, etc.

• Synchronous Concurrency

In synchronous execution, the system flow is controlled by the environment, and internal entities must execute at its pace, in permanent synchrony. Time is now shared between entities and is represented as time steps or as a series of events, both triggered by the surrounding environment.

In my personal experience, when saying “concurrency” people assume asynchronous concurrency, excluding all synchronous reactive languages/systems.

For example, if I state that event-driven programming is a concurrency model, I’ll probably be inquired about this position.

However, if you agree with Wikipedia’s definition and thinks about an event-driven implemented game with hundreds of entities interacting, how can it not be considered “concurrent”?

In a paper from Gerard Berry [1], this “prejudice” is also commented:

Being somewhat unclassical compared to prevalent CSP or CCS based models, it took more time for the synchronous model to be accepted in the mainstream Computer Science community.

Execution model is just one property of concurrent systems. I did not discuss here communication, synchronization, parallelism, determinism…

Maybe it is time to build something like a “Taxonomy for Concurrency”, enumerating all recurrent properties found in concurrency models and languages. Does anyone know about an existing work in this direction?

[1] Gérard Berry, The foundations of Esterel, Proof, language, and interaction: essays in honour of Robin Milner, MIT Press, Cambridge, MA, 2000

Our institution of higher ed began using web-conferencing about a year ago. By the end of the year we had 100 host licenses. A host is a user who can initiate a meeting/training/support session. Attendees need not have a license – just hosts.

I began using it to permit faculty to connect to our weekly walk-in training opportunities. While most participating still attended the face-to-face option, some connected from across the state (I had one connect from Washington DC while attending a conference) and others from their desks across campus or from home.

Several staff members used web-conferencing for administrative purposes such as virtual meetings. No doubt, it saved on institutional travel expenses (travel for a dozen or so people is going to be much more expensive than calling into a teleconference). Unfortunately, we don’t have a good way of measuring this. We would need to track what we did not spend from one budget line item, and compare it to what we actually spent in a different budget line item.

Another group included instructors who were looking for ways to connect with students at a distance. A couple of faculty used it to provide an orientation to their fully-0nline programs and courses. Others used it to connect with students while away at a conference. This semester one of our faculty decided he would offer a student the opportunity to enroll in his on-campus face-to-face class, who would otherwise not be able to take the course.

When I was working on my masters program in order to complete my requirements, I occasionally had to enroll in sections which were offered in other locations. Although I lived and worked on the main campus, there were not always enough students enrolling in a give course to fill a section. I traveled to locations fifty and a hundred miles away, taught by instructors who also traveled a fair distance just to teach them.

With this technology we can offer students the option of enrolling in a on-ground face-to-face course from their desktop. It might not be for everyone. Students should be advised there may be challenges face-to-face students would not encounter such as not be able to hear questions or comments of students in the classroom, observing nonverbal cues of the instructor, needing to post questions using the chat tool, etc. In order to succeed students need to be reatively comfortable with the technology and willing to take a back seat at times, but for those who are willing and able it may be a viable option.

Today I participated in my first International online class for using Moodle. What a neat experience. The teacher and facilitators of the class used a live software tool to make the course interactive.  Not only where the students from all over the world, the teachers were too.   The main teacher was broadcasting live from Israel and another from Mexico. Many participants were K-12 teachers, professors, graduate students, administrators and IT specialists. I have been monitoring the Flat Classroom project, where high schools kids connect with kids in China, via live sessions like this; however, I have not really experienced many international sessions like this myself in a synchronous environment. Most of the classes in the past that I have taken have mainly been asynchronous.

Even at this day and age, the main focus for online learning is in the area of pedagogy, not andragogy. The mix between the two are very important to me, as I have been teaching Senior Citizens and other adults. Teaching adults has always been at the heart of what I wanted to do in life. Over the last year I have become heavily involved in social media/networking strategies and projects with my current employer and how these tools can be used in various aspects of e-learning. I’m not by far the most acclaimed expert in e-learning; however, I do know that using different methods is essential in teaching in a synchronous/asynchronous environment.  Additionally, how adult learners can use social networking in their learning processes. How can using the social networking (or Web 2.0/3.0) be integrated into the motivation and learning strategies for adults?  How can we use these social networking tools to break down the digital divide that still exists? How can we use the social networking tools to further the informal learning processes for adults? As the use of social media/networking tools continues to be adapted world-wide, there will be many choices now and in the future for providing many ways for e-learning to occur.

I think back to when I was young and how I would visit my grandparents on Saturday’s. Not only did we watch the Lawrence Welk show, we listened to the Beach Boys on an 8-Track. Not long after that came cassette tapes, then CD with CD Players, now music players the size of your thumb or less. The adaptation for listening to music to what it is now, has happened over a 40-60 year span. The last 5-10 years e-learning has become much more popular, thus, still has a long way to go.

“Since we live in an age of innovation, a practical education must prepare a man for work that does not yet exist and cannot yet be clearly defined.” ~Peter F. Drucker

A personal note: I have learned so much from using social networking tools from so many experts. If these software tools had never come to be, I would still be in my own little silo.

You are welcome to comment; however, all opinions and comments written in the post are solely my opinions.

Flickr Creative Commons image from James Cridland

I love working asynchronously in text. I can read and write quickly so it suits me. But it sure doesn’t suit everyone. One trend I’m noticing with my clients is a preference for synchronous online interactions, from quick Skype calls to organized web meetings using tools that allow desktop sharing, white boards and even video. (I have to say, for one who has a lot of meetings at 6am in the morning, I’m NOT a fan of video at that time of day!)

Even across diverse time zones, there is more synchronous. Even Twitter – which can sit both in a synch and asynch place, keeps us in that “in the moment” mode.

What are you seeing in your online life? More synchronous? Less? The same? What synchronous tools are popular in your communities and networks?

Managed Threading

Threading Objects and Features

A process is a collection of virtual memory space, code, data, and system resources. A thread is code that is to be serially executed within a process. A processor executes threads, not processes, so each application has at least one process, and a process always has at least one thread of execution, known as the primary thread. A process can have multiple threads in addition to the primary thread.

Processes communicate with one another through messages, using Microsoft’s Remote Procedure Call (RPC) technology to pass information to one another. There is no difference to the caller between a call coming from a process on a remote machine and a call coming from another process on the same machine.

When a thread begins to execute, it continues until it is killed or until it is interrupted by a thread with higher priority (by a user action or the kernel’s thread scheduler). Each thread can run separate sections of code, or multiple threads can execute the same section of code. Threads executing the same block of code maintain separate stacks. Each thread in a process shares that process’s global variables and resources.

Threads are the basic unit to which an operating system allocates processor time, and more than one thread can be executing code inside that process. Each thread maintains

• exception handlers,
• a scheduling priority, and
• a set of structures the system uses to save the thread context until it is scheduled.

The thread context includes all the information the thread needs to seamlessly resume execution, including

• the thread’s set of CPU registers and
• stack, in the address space of the thread’s host process.

The .NET Framework further subdivides an operating system process into lightweight managed subprocesses, called application domains, represented by System..::.AppDomain. One or more managed threads (represented by System.Threading..::.Thread) can run in one or any number of application domains within the same managed process. Although each application domain is started with a single thread, code in that application domain can create additional application domains and additional threads. The result is that a managed thread can move freely between application domains inside the same managed process; you might have only one thread moving among several application domains.

If your application uses only one thread of execution, you can combine asynchronous programming with .NET Framework remoting or XML Web services created using ASP.NET to use the processing time of other computers in addition to that of your own to increase responsiveness to the user and decrease the data processing time of your application.

Disadvantages of Multiple Threads

It is recommended that you use as few threads as possible, thereby minimizing the use of operating-system resources and improving performance. Threading also has resource requirements and potential conflicts to be considered when designing your application. The resource requirements are as follows:

• The system consumes memory for the context information required by processes, AppDomain objects, and threads. Therefore, the number of processes, AppDomain objects, and threads that can be created is limited by available memory.
• Keeping track of a large number of threads consumes significant processor time. If there are too many threads, most of them will not make significant progress. If most of the current threads are in one process, threads in other processes are scheduled less frequently.
• Controlling code execution with many threads is complex, and can be a source of many bugs.
• Destroying threads requires knowing what could happen and handling those issues.

Resources that require synchronization include:

• System resources (such as communications ports).
• Resources shared by multiple processes (such as file handles).
• The resources of a single application domain (such as global, static, and instance fields) accessed by multiple threads.

Synchronizing Data for Multithreading

When multiple threads can make calls to the properties and methods of a single object, it is critical that those calls be synchronized. Otherwise one thread might interrupt what another thread is doing, and the object could be left in an invalid state. A class whose members are protected from such interruptions is called thread-safe.

The Common Language Infrastructure provides several strategies to synchronize access to instance and static members:

• Synchronized code regions. You can use the Monitor class or compiler support for this class to synchronize only the code block that needs it, improving performance.
• Manual synchronization.You can use the synchronization objects provided by the .NET Framework class library. See Overview of Synchronization Primitives, which includes a discussion of the Monitor class.
• Synchronized contexts. You can use the SynchronizationAttribute to enable simple, automatic synchronization for ContextBoundObject objects.
• Synchronized property. A few classes, such as Hashtable and Queue, provide a Synchronized property that returns a thread-safe wrapper for an instance of the class. See Collections and Synchronization (Thread Safety).

The common language runtime provides a thread model in which classes fall into a number of categories that can be synchronized in a variety of different ways depending on the requirements. The following table shows what synchronization support is provided for fields and methods with a given synchronization category.

Category	Global fields	Static fields	Static methods	Instance fields	Instance methods	Specific code blocks
No Synchronization	No	No	No	No	No	No
Synchronized Context	No	No	No	Yes	Yes	No
Synchronized Code Regions	No	No	Only if marked	No	Only if marked	Only if marked
Manual Synchronization	Manual	Manual	Manual	Manual	Manual	Manual

Threading and Application Design

In general, using the ThreadPool class is the easiest way to handle multiple threads for relatively short tasks that will not block other threads and when you do not expect any particular scheduling of the tasks. However, there are a number of reasons to create your own threads:

• If you need a task to have a particular priority.
• If you have a task that might run a long time (and therefore block other tasks).
• If you need to place threads into a single-threaded apartment (all ThreadPool threads are in the multithreaded apartment).
• If you need a stable identity associated with the thread. For example, you should use a dedicated thread to abort that thread, suspend it, or discover it by name.
• If you need to run background threads that interact with the user interface, the .NET Framework version 2.0 provides a BackgroundWorker component that communicates using events, with cross-thread marshaling to the user-interface thread.

Apartment Threading (Single Threaded Apartment)

Apartment threaded means there are multiple threads within the application. In single threaded apartment (STA) each thread is isolated in a separate apartment underneath the process. The process can have any number of apartments that share data through a proxy. The application defines when and for how long the thread in each apartment should execute. All requests are serialized through the Windows message queue such that only a single apartment is accessed at a time and thus only a single thread will be executing at any one time. STA is the threading model that most Visual Basic developers are familiar with because this is the threading model available to VB applications prior to VB.NET. You can think of it like an apartment building full of a row of one room apartments that are accessible one at a time through a single hallway. The advantage this provides over single threaded is that multiple commands can be issued at one time instead of just a single command, but the commands are still sequentially executed.

Free Threading (Multi Threaded Apartment)

Free threaded applications were limited to programming languages such as C++ until the release of Microsoft .NET. The free threaded/Multi Threaded Apartment (MTA) model has a single apartment created underneath the process rather than multiple apartments. This single apartment holds multiple threads rather than just a single thread. No message queue is required because all of the threads are a part of the same apartment and can share data without a proxy. You can think of it like a building with multiple rooms that are all accessible once you are inside the building. These applications typically execute faster than single threaded and STA because there is less system overhead and can be optimized to eliminate system idle time.

These types of applications are more complex to program. The developer must provide thread synchronization as part of the code to ensure that threads do not simultaneously access the same resources. A condition known as a race condition can occur when a thread accesses a shared resource and modifies the resource to an invalid state and then another thread accesses the shared resource and uses it in the invalid state before the other thread can return the resource to a valid state. Therefore it is necessary to place a lock on a resource to prevent other threads from accessing the resource until the lock has been removed. However, this can lead to a deadlock situation where two threads are competing for resources and neither can proceed.

The only way to avoid situations like these is through good design and testing.

Rules for single-threaded apartments are simple, but it is important to follow them carefully:

• Every object should live on only one thread (within a single-threaded apartment).
• Initialize the COM library for each thread.
• Marshal all pointers to objects when passing them between apartments.
• Each single-threaded apartment must have a message loop to handle calls from other processes and apartments within the same process. Single-threaded apartments without objects (client only) also need a message loop to dispatch the broadcast messages that some applications use.
• DLL-based or in-process objects do not call the COM initialization functions; instead, they register their threading model with the ThreadingModel named-value under the InprocServer32 key in the registry. Apartment-aware objects must also write DLL entry points carefully. There are special considerations that apply to threading in-process servers. For more information, see In-Process Server Threading Issues.

Following are some important considerations regarding synchronization for multithreaded apartments:

• COM provides call synchronization for single-threaded apartments only.
• Multithreaded apartments do not receive calls while making calls (on the same thread).
• Multithreaded apartments cannot make input-synchronized calls.
• Asynchronous calls are converted to synchronous calls in multithreaded apartments.
• The message filter is not called for any thread in a multithreaded apartment.

Important Note:

Do not lock the type — that is, typeof(MyType) in C#, GetType(MyType) in Visual Basic, or MyType::typeid in C++ — in order to protect static methods (Shared methods in Visual Basic). Use a private static object instead. Similarly, do not use this in C# (Me in Visual Basic) to lock instance methods. Use a private object instead. A class or instance can be locked by code other than your own, potentially causing deadlocks or performance problems.

Synchronized Context

You can use the SynchronizationAttribute on any ContextBoundObject to synchronize all instance methods and fields. All objects in the same context domain share the same lock. Multiple threads are allowed to access the methods and fields, but only a single thread is allowed at any one time.

Setting Up for a Background Operation

To set up for a background operation, add an event handler for the DoWork event. Call your time-consuming operation in this event handler.To start the operation, call RunWorkerAsync. To receive notifications of progress updates, handle the ProgressChanged event. To receive a notification when the operation is completed, handle the RunWorkerCompleted event.The methods that handle the ProgressChanged and RunWorkerCompleted events can access the application’s user interface, because those events are raised on the thread that called the RunWorkerAsync method. However, the DoWork event handler cannot work with any user-interface objects because it runs on the background thread.

Safe Points

Multithreaded Applications.

You can provide parameters and return values to thread-pool threads by using the optional ByVal state-object variable of the QueueUserWorkItem method. Thread-timer threads also support a state object for this purpose. For information on thread pooling and thread timers, see Thread Pooling and Thread Timers.

Sub DoWork()
    ' Queue a task
    System.Threading.ThreadPool.QueueUserWorkItem( _
        New System.Threading.WaitCallback(AddressOf SomeLongTask))
    ' Queue another task
    System.Threading.ThreadPool.QueueUserWorkItem( _
        New System.Threading.WaitCallback(AddressOf AnotherLongTask))
End Sub
Sub SomeLongTask(ByVal state As Object)
    ' Insert code to perform a long task.
End Sub
Sub AnotherLongTask(ByVal state As Object)
    ' Insert code to perform another long task.
End Sub

Application Domains and Threads.

Events (C#).

Events can be used to synchronize threads.

Delegate is a creatable type. Programming with delegates requires creating delegate objects from delegate types.

Delegates seamlessly support binding a notification source to multiple handler methods through a feature known as multicasting.

Delegate binding, see Delegates in the Common Type System and CreateDelegate(Type,Object,MethodInfo,Boolean).

Delegates are referred to as

• multicast, or
• combinable,

because a delegate can invoke one or more methods and can be used in combining operations.A delegate can represent a

• static method or
• an instance method.

When the delegate represents an instance method, the delegate stores not only a reference to the method’s entry point, but also a reference to the class instance. Unlike function pointers,

• delegates are object oriented and
• type safe.

How to: Subscribe to and Unsubscribe from Events (C# Programming Guide)

The line of code that is needed to subscribe to the event is also automatically generated in the InitializeComponent method in the Form1.Designer.cs file in your project. It looks like this:

  this.Load += new System.EventHandler(this.Form1_Load);

To subscribe to events programmatically

1. Define an event handler method whose signature matches the delegate signature for the event. For example, if the event is based on the EventHandler delegate type, then the following code represents the method stub:

     void HandleCustomEvent(object sender, CustomEventArgs a)
     {
        // Do something useful here.
     }

2. Use the addition assignment operator (+=) to attach your event handler to the event. In the following example, assume that an object named publisher has an event named RaiseCustomEvent. Note that the subscriber class needs a reference to the publisher class in order to subscribe to its events.

   publisher.RaiseCustomEvent += HandleCustomEvent;

Note that the above syntax is new in C# 2.0. It is exactly equivalent to the C# 1.0 syntax in which the encapsulating delegate must be explicitly created using the new keyword:

publisher.RaiseCustomEvent += new CustomEventHandler(HandleCustomEvent);

To subscribe to events by using an anonymous method

• Use the addition assignment operator (+=) to attach your anonymous method to the event. In the following example, assume that an object named publisher has an event named RaiseCustomEvent and that a CustomEventArgs class has also been defined to carry some kind of specialized event information. Note that the subscriber class needs a reference to publisher in order to subscribe to its events.

    publisher.RaiseCustomEvent += delegate(object o, CustomEventArgs e)
    {
      string s = o.ToString() + " " + e.ToString();
      Console.WriteLine(s);
    };

It is important to note that you cannot easily unsubscribe from an event if you used an anonymous method to subscribe to it. To unsubscribe in this scenario, go back to the code where you subscribe to the event, store the anonymous method in a delegate variable, and then add the delegate to the event.

When an event has multiple subscribers, the event handlers are invoked synchronously when an event is raised. To invoke events asynchronously, see Calling Synchronous Methods Asynchronously.

four common ways to use BeginInvoke and EndInvoke to make asynchronous calls. After calling BeginInvoke you can do the following:

• Do some work and then call EndInvoke to block until the call completes.
• Obtain a WaitHandle using the System.IAsyncResult.AsyncWaitHandle property, use its WaitOne method to block execution until the WaitHandle is signaled, and then call EndInvoke.
• Poll the IAsyncResult returned by BeginInvoke to determine when the asynchronous call has completed, and then call EndInvoke.
• Pass a delegate for a callback method to BeginInvoke. The method is executed on a ThreadPool thread when the asynchronous call completes. The callback method calls EndInvoke.

  Important
  Always call EndInvoke to complete your asynchronous call.

you should know that events in the .NET Framework are layered on top of delegates. When you use an event-driven application framework such as Windows® Forms or ASP.NET, your knowledge of delegates will make you a much stronger developer.

Delegates provide the primary means in .NET for executing a method on a secondary thread in an asynchronous fashion. Therefore, delegates open the door to multithreading.

the compiler generates a class definition for each delegate type. The class that is generated for each delegate type is a creatable class that inherits from the System.Multicast delegate.

compiler has also added a public constructor and three public methods named

• Invoke,
• BeginInvoke, and
• EndInvoke.

Asynchronous Programming Design Patterns

Asynchronous operations are typically used to perform tasks that might take a long time to complete, such as opening large files, connecting to remote computers, or querying a database. An asynchronous operation executes in a thread separate from the main application thread. When an application calls methods to perform an operation asynchronously, the application can continue executing while the asynchronous method performs its task.

Asynchronous programming is a feature supported by many areas of the .NET Framework, including:

• File IO, Stream IO, Socket IO.
• Networking.
• Remoting channels (HTTP, TCP) and proxies.
• XML Web services created using ASP.NET.
• ASP.NET Web Forms.
• Message Queuing using the MessageQueue class.

The .NET Framework provides two design patterns for asynchronous operations:

• Asynchronous operations that use IAsyncResult objects.
• Asynchronous operations that use events. Event-based Asynchronous Pattern Overview.

For relatively simple multithreaded applications, the BackgroundWorker component provides a straightforward solution. For more sophisticated asynchronous applications, consider implementing a class that adheres to the Event-based Asynchronous Pattern.

Asynchronous Programming Overview

Discusses the IAsyncResult based asynchronous design pattern, which provides a flexible programming model to deal with asynchronous operations.

The correct choice depends on whether the application has instructions that can execute while the operation completes. If an application cannot perform any additional work until it receives the results of the asynchronous operation, the application must block until the results are available. To block until an asynchronous operation completes, you can use one of the following approaches:

• Call EndOperationName from the application’s main thread, blocking application execution until the operation is complete. For an example that illustrates this technique, see Blocking Application Execution by Ending an Asynchronous Operation.
• Use the AsyncWaitHandle to block application execution until one or more operations are complete. For an example that illustrates this technique, see Blocking Application Execution Using an AsyncWaitHandle.

Applications that do not need to block while the asynchronous operation completes can use one of the following approaches:

• Poll for operation completion status by checking the IsCompleted property periodically and calling EndOperationName when the operation is complete. For an example that illustrates this technique, see Polling for the Status of an Asynchronous Operation.
• Use an AsyncCallback delegate to specify a method to be invoked when the operation is complete. For an example that illustrates this technique, see Using an AsyncCallback Delegate to End an Asynchronous Operation.

Creating Event Handlers in Windows Forms

• How to: Subscribe to and Unsubscribe from Events (C# Programming Guide)
• How to: Publish Events that Conform to .NET Framework Guidelines (C# Programming Guide)
• How to: Raise Base Class Events in Derived Classes (C# Programming Guide)
• How to: Implement Interface Events (C# Programming Guide)
• Thread Synchronization (C# Programming Guide)
• How to: Use a Dictionary to Store Event Instances (C# Programming Guide)
• Events Sample
• Event Design

Multithreading in Components

Managed Threading Best Practices

Implementing the Event-based Asynchronous Pattern

Describes the standardized way to package a class that has asynchronous features.

features of the Event-based Asynchronous Pattern discussed in this topic.

• Opportunities for Implementing the Event-based Asynchronous Pattern
• Naming Asynchronous Methods
• Optionally Support Cancellation
• Optionally Support the IsBusy Property
• Optionally Provide Support for Progress Reporting
• Optionally Provide Support for Returning Incremental Results
• Handling Out and Ref Parameters in Methods

Deciding When to Implement the Event-based Asynchronous Pattern

Describes how to determine when you should choose to implement the Event-based Asynchronous Pattern instead of the IAsyncResult pattern.

Event-based Asynchronous Pattern Technology Sample

Shows how to use the Event-based Asynchronous Pattern to perform common asynchronous operations.

Events and Delegates

How to: Run an Operation in the Background

use the BackgroundWorker class to run the operation on another thread.

Robust Programming

Caution
When using multithreading of any sort, you potentially expose yourself to very serious and complex bugs. Consult the Managed Threading Best Practices before implementing any solution that uses multithreading.

Deadlocks

A deadlock occurs when each of two threads tries to lock a resource the other has already locked. Neither thread can make any further progress.

Many methods of the managed threading classes provide time-outs to help you detect deadlocks. For example, the following code attempts to acquire a lock on the current instance. If the lock is not obtained in 300 milliseconds, Monitor.TryEnter returns false.

Race Conditions

A race condition is a bug that occurs when the outcome of a program depends on which of two or more threads reaches a particular block of code first. Running the program many times produces different results, and the result of any given run cannot be predicted.

A simple example of a race condition is incrementing a field. Suppose a class has a private static field (Shared in Visual Basic) that is incremented every time an instance of the class is created, using code such as objCt++; (C#) or objCt += 1 (Visual Basic). This operation requires loading the value from objCt into a register, incrementing the value, and storing it in objCt.

In a multithreaded application, a thread that has loaded and incremented the value might be preempted by another thread which performs all three steps; when the first thread resumes execution and stores its value, it overwrites objCt without taking into account the fact that the value has changed in the interim.

This particular race condition is easily avoided by using methods of the Interlocked class, such as Interlocked.Increment. To read about other techniques for synchronizing data among multiple threads, see Synchronizing Data for Multithreading.

Race conditions can also occur when you synchronize the activities of multiple threads. Whenever you write a line of code, you must consider what might happen if a thread were preempted before executing the line (or before any of the individual machine instructions that make up the line), and another thread overtook it.

Overview of Synchronization Primitives

The .NET Framework provides a range of synchronization primitives for controlling the interactions of threads and avoiding race conditions. These can be roughly divided into three categories:

• locking,
• signaling, and
• interlocked operations.

The categories are not tidy and clearly defined: some synchronization mechanisms have characteristics of multiple categories; events that release a single thread at a time are functionally like locks; the release of any lock can be thought of as a signal; and interlocked operations can be used to construct locks. However, the categories are still useful.

Signaling

The simplest way to wait for a signal from another thread is to call the Join method, which blocks until the other thread completes. Join has two overloads that allow the blocked thread to break out of the wait after a specified interval has elapsed.

Wait handles provide a much richer set of waiting and signaling capabilities.

Wait Handles

Wait handles derive from the WaitHandle class, which in turn derives from MarshalByRefObject. Thus, wait handles can be used to synchronize the activities of threads across application domain boundaries.

Threads block on wait handles by calling the instance method WaitOne or one of the static methods WaitAll, WaitAny, or SignalAndWait. How they are released depends on which method was called, and on the kind of wait handles.

For a conceptual overview, see Wait Handles. Also EventWaitHandle, AutoResetEvent, and ManualResetEvent.

Interlocked Operations

Interlocked operations are simple atomic operations performed on a memory location by static methods of the Interlocked class. Those atomic operations include addition, increment and decrement, exchange, conditional exchange depending on a comparison, and read operations for 64-bit values on 32-bit platforms.

Note:
The guarantee of atomicity is limited to individual operations; when multiple operations must be performed as a unit, a more coarse-grained synchronization mechanism must be used.

Although none of these operations are locks or signals, they can be used to construct locks and signals. Because they are native to the Windows operating system, interlocked operations are extremely fast.

Interlocked operations can be used with volatile memory guarantees to write applications which exhibit powerful non-blocking concurrency, however they require sophisticated, low level programming, and for most purposes simple locks are a better choice.

For a conceptual overview, see Interlocked Operations.

SynchronizationAttribute

When this attribute is applied to an object, only one thread can be executing in all contexts that share an instance of this property. This is done by contributing sinks that intercept and serialize incoming calls for the respective contexts. If the property is marked for reentry, then callouts are intercepted too. The callout interception allows other waiting threads to enter the synchronization domain for maximal throughput.

Note:

There are two classes named SynchronizationAttribute : one in the System.Runtime.Remoting.Contexts namespace, and the other in the System.EnterpriseServices namespace. The System.EnterpriseServices..::.SynchronizationAttribute class supports only synchronous calls, and can be used only with serviced components. (For more information on serviced components, see [<topic://cpconservicedcomponentoverview>].) The System.Runtime.Remoting.Contexts..::.SynchronizationAttribute supports both synchronous and asynchronous calls, and can be used only with context bound objects. (For more information on context bound objects, see the ContextBoundObject class.)

Recommendations for Class Libraries

Consider the following guidelines when designing class libraries for multithreading:

• Avoid the need for synchronization, if possible. This is especially true for heavily used code. For example, an algorithm might be adjusted to tolerate a race condition rather than eliminate it. Unnecessary synchronization decreases performance and creates the possibility of deadlocks and race conditions.
• Make static data (Shared in Visual Basic) thread safe by default.
• Do not make instance data thread safe by default. Adding locks to create thread-safe code decreases performance, increases lock contention, and creates the possibility for deadlocks to occur. In common application models, only one thread at a time executes user code, which minimizes the need for thread safety. For this reason, the .NET Framework class libraries are not thread safe by default.
• Avoid providing static methods that alter static state. In common server scenarios, static state is shared across requests, which means multiple threads can execute that code at the same time. This opens up the possibility of threading bugs. Consider using a design pattern that encapsulates data into instances that are not shared across requests. Furthermore, if static data are synchronized, calls between static methods that alter state can result in deadlocks or redundant synchronization, adversely affecting performance.

General Recommendations

Consider the following guidelines when using multiple threads:

• Don’t use Thread.Abort to terminate other threads. Calling Abort on another thread is akin to throwing an exception on that thread, without knowing what point that thread has reached in its processing.
• Don’t use Thread.Suspend and Thread.Resume to synchronize the activities of multiple threads. Do use
• • Mutex,
  • ManualResetEvent,
  • AutoResetEvent,
  • Monitor.
• Don’t control the execution of worker threads from your main program (using events, for example). Instead, design your program so that worker threads are responsible for waiting until work is available, executing it, and notifying other parts of your program when finished. If your worker threads do not block, consider using thread pool threads. Monitor.PulseAll is useful in situations where worker threads block.
• The Birth of the Thread Pool
  Capability 1: Calling a Method Asynchronously
  Capability 2: Calling a Method at Timed Intervals
  Capability 3: Calling a Method When a Single Kernel Object Becomes Signaled
• Don’t use types as lock objects. That is, avoid code such as lock(typeof(X)) in C# or SyncLock(GetType(X)) in Visual Basic, or the use of System.Threading.Monitor.Enter(System.Object) with Type objects. For a given type, there is only one instance of System.Type per application domain. If the type you take a lock on is public, code other than your own can take locks on it, leading to deadlocks. For additional issues, see Reliability Best Practices.
• Use caution when locking on instances, for example lock(this) in C# or SyncLock(Me) in Visual Basic. If other code in your application, external to the type, takes a lock on the object, deadlocks could occur.
• Do ensure that a thread that has entered a monitor always leaves that monitor, even if an exception occurs while the thread is in the monitor. The C# lock statement and the Visual Basic SyncLock statement provide this behavior automatically, employing a finally block to ensure that Monitor.Exit is called. If you cannot ensure that Exit will be called, consider changing your design to use Mutex. A mutex is automatically released when the thread that currently owns it terminates.
• Do use multiple threads for tasks that require different resources, and avoid assigning multiple threads to a single resource. For example, any task involving I/O benefits from having its own thread, because that thread will block during I/O operations and thus allow other threads to execute. User input is another resource that benefits from a dedicated thread. On a single-processor computer, a task that involves intensive computation coexists with user input and with tasks that involve I/O, but multiple computation-intensive tasks contend with each other.
• Consider using methods of the Interlocked class for simple state changes, instead of using the lock statement (SyncLock in Visual Basic). The lock statement is a good general-purpose tool, but the Interlocked class provides better performance for updates that must be atomic. Internally, it executes a single lock prefix if there is no contention. In code reviews, watch for code like that shown in the following examples. In the first example, a state variable is incremented:

Performance Considerations with Locks, Threads, Semaphores

You can improve performance by using the Increment method instead of the lock statement, as follows:

C#

System.Threading.Interlocked.Increment(myField);

In the second example, a reference type variable is updated only if it is a null reference (Nothing in Visual Basic).

C#

if (x == null)
{
    lock (lockObject)
    {
        if (x == null)
        {
            x = y;
        }
    }
}

Performance can be improved by using the CompareExchange method instead, as follows:

C#

System.Threading.Interlocked.CompareExchange(ref x, y, null);

The methods of this class help protect against errors that can occur when the scheduler switches contexts while a thread is updating a variable that can be accessed by other threads, or when two threads are executing concurrently on separate processors. The members of this class do not throw exceptions.The Increment and Decrement methods increment or decrement a variable and store the resulting value in a single operation. On most computers, incrementing a variable is not an atomic operation, requiring the following steps:

1. Load a value from an instance variable into a register.
2. Increment or decrement the value.
3. Store the value in the instance variable.

If you do not use Increment and Decrement, a thread can be preempted after executing the first two steps. Another thread can then execute all three steps. When the first thread resumes execution, it overwrites the value in the instance variable, and the effect of the increment or decrement performed by the second thread is lost.

The Exchange method atomically exchanges the values of the specified variables. The CompareExchange method combines two operations: comparing two values and storing a third value in one of the variables, based on the outcome of the comparison. The compare and exchange operations are performed as an atomic operation.

//A simple method that denies reentrancy.
        static bool UseResource()
        {
            //0 indicates that the method is not in use.
            if(0 == Interlocked.Exchange(ref usingResource, 1))
            {
                Console.WriteLine("{0} acquired the lock", Thread.CurrentThread.Name);

                //Code to access a resource that is not thread safe would go here.

                //Simulate some work
                Thread.Sleep(500);

                Console.WriteLine("{0} exiting lock", Thread.CurrentThread.Name);

                //Release the lock
                Interlocked.Exchange(ref usingResource, 0);
                return true;
            }
            else
            {
                Console.WriteLine("   {0} was denied the lock", Thread.CurrentThread.Name);
                return false;
            }
        }

Source Code Examples

• Part 1 – Creating a thread in Windows Forms -  Some basic ideas about firing a background and how to synchronize it with the UI.
• Part 2 – Using BackgroundWorker -  the .NET 2.0 way using a BackgroundWorker component

• Part 3 – Automatic Marshalling – creating your own component with auto marshalling

When Not to Use Thread Pool Threads

There are several scenarios in which it is appropriate to create and manage your own threads instead of using thread pool threads:

• You require a foreground thread.
• You require a thread to have a particular priority.
• You have tasks that cause the thread to block for long periods of time. The thread pool has a maximum number of threads, so a large number of blocked thread pool threads might prevent tasks from starting.
• You need to place threads into a single-threaded apartment. All ThreadPool threads are in the multithreaded apartment.
• You need to have a stable identity associated with the thread, or to dedicate a thread to a task.

BackgroundWorker Component Overview

Describes the BackgroundWorker component, which gives you the ability to execute time-consuming operations asynchronously (“in the background”), on a thread different from your application’s main UI thread.

There are many commonly performed operations that can take a long time to execute. For example:

• Image downloads
• Web service invocations
• File downloads and uploads (including for peer-to-peer applications)
• Complex local computations
• Database transactions
• Local disk access, given its slow speed relative to memory access

System.MarshalByRefObject
System.ComponentModel.Component
System.ComponentModel.BackgroundWorker

BackgroundWorker

Describes this class and has links to all its members.

To execute a time-consuming operation in the background, create a BackgroundWorker and listen for events that report the progress of your operation and signal when your operation is finished. You can create the BackgroundWorker programmatically or you can drag it onto your form from the Components tab of the Toolbox. If you create the BackgroundWorker in the Windows Forms Designer, it will appear in the Component Tray, and its properties will be displayed in the Properties window.

To set up for a background operation, add an event handler for the DoWork event. Call your time-consuming operation in this event handler. To start the operation, call RunWorkerAsync. To receive notifications of progress updates, handle the ProgressChanged event. To receive a notification when the operation is completed, handle the RunWorkerCompleted event.

Note:
You must be careful not to manipulate any user-interface objects in your DoWork event handler. Instead, communicate to the user interface through the ProgressChanged and RunWorkerCompleted events.BackgroundWorker events are not marshaled across AppDomain boundaries. Do not use a BackgroundWorker component to perform multithreaded operations in more than one AppDomain.

If your background operation requires a parameter, call RunWorkerAsync with your parameter. Inside the DoWork event handler, you can extract the parameter from the DoWorkEventArgs.Argument property.

System.Threading..::.ThreadPool

Remarks

Note:

The HostProtectionAttribute attribute applied to this type or member has the following Resources property value: Synchronization | ExternalThreading. The HostProtectionAttribute does not affect desktop applications (which are typically started by double-clicking an icon, typing a command, or entering a URL in a browser). For more information, see the HostProtectionAttribute class or SQL Server Programming and Host Protection Attributes.

Many applications create threads that spend a great deal of time in the sleeping state, waiting for an event to occur. Other threads might enter a sleeping state only to be awakened periodically to poll for a change or update status information. Thread pooling enables you to use threads more efficiently by providing your application with a pool of worker threads that are managed by the system. One thread monitors the status of several wait operations queued to the thread pool. When a wait operation completes, a worker thread from the thread pool executes the corresponding callback function.

Note:
The threads in the managed thread pool are background threads. That is, their IsBackground properties are true. This means that a ThreadPool thread will not keep an application running after all foreground threads have exited.

You can also queue work items that are not related to a wait operation to the thread pool. To request that a work item be handled by a thread in the thread pool, call the QueueUserWorkItem method. This method takes as a parameter a reference to the method or delegate that will be called by the thread selected from the thread pool. There is no way to cancel a work item after it has been queued.

Timer-queue timers and registered wait operations also use the thread pool. Their callback functions are queued to the thread pool.

There is one thread pool per process. The thread pool has a default size of 250 worker threads per available processor, and 1000 I/O completion threads. The number of threads in the thread pool can be changed by using the SetMaxThreads method. Each thread uses the default stack size and runs at the default priority.

The thread pool maintains a minimum number of idle threads. For worker threads, the default value of this minimum is the number of processors. The GetMinThreads method obtains the minimum numbers of idle worker and I/O completion threads.

When all thread pool threads have been assigned to tasks, the thread pool does not immediately begin creating new idle threads. To avoid unnecessarily allocating stack space for threads, it creates new idle threads at intervals. The interval is currently half a second, although it could change in future versions of the .NET Framework.

If an application is subject to bursts of activity in which large numbers of thread pool tasks are queued, use the SetMinThreads method to increase the minimum number of idle threads. Otherwise, the built-in delay in creating new idle threads could cause a bottleneck.

Note:
Unnecessarily increasing the number of idle threads can also cause performance problems. Stack space must be allocated for each thread. If too many tasks start at the same time, all of them might appear to be slow. Finding the right balance is a performance-tuning issue.

When the thread pool reuses a thread, it does not clear the data in thread local storage or in fields that are marked with the ThreadStaticAttribute attribute. Therefore, data that is placed in thread local storage by one method can be exposed to any other method that is executed by the same thread pool thread. A method that accesses a field that is marked with the ThreadStaticAttribute attribute could encounter different data depending on which thread pool thread executes it.

Starting with the .NET Framework version 2.0 Service Pack 1, the throughput of the thread pool is significantly improved for applications that make heavy use of small thread pool tasks. These applications will see improvements in three areas:

• queuing tasks,
• dispatching thread pool threads, and
• dispatching I/O completion threads.

To use this functionality, your application should target the .NET Framework version 3.5. For more information, see .NET Framework 3.5 Architecture.

More Samples, .NET Snippets

use the Invoke Method of the ISynchronizeInvoke Interface:

CODE

#region UpdateStatus
private static void UpdateStatus(string msg, string status)
{
//create our Object Array
object[] items = new object[2];
//populate our array with the parameters
//passed to our method
items[0] = msg;
items[1] = status;
//call the delegate
_synch.Invoke(_status, items);
}
#endregion

Using this we can update any UI component in the main thread without worrying if the call is being made from the proper thread. So as you can see, there is a thread-safe way to share data between threads. Though we aren’t using data, we’re simply updating a component on the UI with the status of our background thread. This process can now rune while leaving the UI in a usable state.

Basic Instincts: Implementing Callbacks with a Multicast Delegate.

is a follow-up to the December 2002 installment in which I introduced the basic concepts and programming techniques associated with delegates. I am going to assume you have already read that column and that you are familiar with the fundamentals of programming delegates. For example, you should know how to define a delegate type, how to create a delegate object that’s bound to a handler method, and how to execute the handler method by calling the delegate object’s Invoke method.

How to: Combine Delegates (Multicast Delegates)(C#).

This example demonstrates how to compose multicast delegates. A useful property of delegate objects is that they can be assigned to one delegate instance to be multicast using the + operator. A composed delegate calls the two delegates it was composed from. Only delegates of the same type can be composed.

The - operator can be used to remove a component delegate from a composed delegate.

Example

C#

delegate void Del(string s);

class TestClass
{
    static void Hello(string s)
    {
        System.Console.WriteLine("  Hello, {0}!", s);
    }

    static void Goodbye(string s)
    {
        System.Console.WriteLine("  Goodbye, {0}!", s);
    }

    static void Main()
    {
        Del a, b, c, d;

        // Create the delegate object a that references 
        // the method Hello:
        a = Hello;

        // Create the delegate object b that references 
        // the method Goodbye:
        b = Goodbye;

        // The two delegates, a and b, are composed to form c: 
        c = a + b;

        // Remove a from the composed delegate, leaving d, 
        // which calls only the method Goodbye:
        d = c - a;

        System.Console.WriteLine("Invoking delegate a:");
        a("A");
        System.Console.WriteLine("Invoking delegate b:");
        b("B");
        System.Console.WriteLine("Invoking delegate c:");
        c("C");
        System.Console.WriteLine("Invoking delegate d:");
        d("D");
    }
}

Output

Invoking delegate a:
  Hello, A!
Invoking delegate b:
  Goodbye, B!
Invoking delegate c:
  Hello, C!
  Goodbye, C!
Invoking delegate d:
  Goodbye, D!

See Also

Reference

MulticastDelegate

Concepts

C# Programming Guide
Events (C# Programming Guide)

Quick factories using delegates

Delegates are very useful to act as object factories. In the example below, it is used to allow the function to build another object based on it, while keeping the function unaware about types.

namespace Microsoft.MSDN.Wiki.Samples
{
    class Vehicle
    {
        int Price;
    }
    class Car : Vehicle
    {
        protected Car(string model, int passengers)
        {
        }
        public static Car Create(string model, int passengers)
        {
            // Perform some check and create a new instance
            return new Car(model, passengers);
        }
        public Vehicle FakeClone(Vehicle src)
        {
            // Cars are special in our example, and will not be cloned
            // return the original object instead
            return src;
        }
    }
    class Bus : Vehicle
    {
        private string model;
        private int passengers;
        private int cargo;
        protected Bus(string model, int passengers, int cargo)
        {
            // Assign variables
            this.model = model;
            this.passengers = passengers;
            this.cargo = cargo;
        }
        public static Bus Create(string model, int passengers, int cargo)
        {
            // TODO: Perform some check and create a new instance
            return new Bus(model, passengers, cargo);
        }
        public Vehicle CloneSpecial(Vehicle src)
        {
            // TODO: Perform some check and clone the instance
            Bus bus = (Bus)src;
            return new Bus(bus.model, bus.passengers, bus.cargo);
        }
    }
    class Program
    {
        public delegate Vehicle CreateNewVehicle(Vehicle src);
        public void ProcessBus(Bus bus)
        {
            ProcessVehicle(bus, bus.CloneSpecial);
        }
        public void ProcessCar(Car car)
        {
            ProcessVehicle(car, car.FakeClone);
        }
        public void ProcessVehicle(Vehicle source, CreateNewVehicle factory)
        {
            // This function might need to clone the vehicle. Use the delegate
            // so the caller can control the creation
            bool needToCloneObject = true;
            if (needToCloneObject)
            {
                Vehicle newObj = factory(source);
                if (newObj != null)
                {
                    // Now we have a new object to work with
                }
            }
        }
        [STAThread]
        public static void Main(string[] args)
        {
        }
    }
}

As you can see we can take the knowledge about the creation logic outside the function when pure inheritance does not work (e.g. having a generic Clone() function in Vehicle) or when the logic changing depending on the context. For example, you might need to clone in a specific way on one condition and clone it differently on another condition.

Anonymous delegates can be used to simplify context changes

you can also use an anonymous delegate to simplify the cloning process. But remember that this technique is not constrained to cloning. That was just the motivation for the example.

namespace Microsoft.MSDN.Wiki.Samples
{
    class Vehicle
    {
        int Price;
    }
    class Car : Vehicle
    {
        protected Car(string model, int passengers)
        {
        }
        public static Car Create(string model, int passengers)
        {
            // Perform some check and create a new instance
            return new Car(model, passengers);
        }
    }
    class Bus : Vehicle
    {
        private string model;
        private int passengers;
        private int cargo;
        protected Bus(string model, int passengers, int cargo)
        {
            // Assign variables
            this.model = model;
            this.passengers = passengers;
            this.cargo = cargo;
        }
        public static Bus Create(string model, int passengers, int cargo)
        {
            // TODO: Perform some check and create a new instance
            return new Bus(model, passengers, cargo);
        }
        public Bus Clone()
        {
            return new Bus(this.model, this.passengers, this.cargo);
        }
    }
    class Program
    {
        public delegate Vehicle CreateNewVehicle(Vehicle src);
        public void ProcessBus(Bus bus)
        {
            ProcessVehicle(bus, delegate(Vehicle src)
            {
                // Perform some special logic
                return ((Bus)src).Clone();
            });
        }
        public void ProcessCar(Car car)
        {
            ProcessVehicle(car, delegate(Vehicle src)
            {
                // Cars are not cloned in this situation
                return src;
            });
        }
        public void ProcessVehicle(Vehicle source, CreateNewVehicle factory)
        {
            // This function might need to clone the vehicle. Use the delegate
            // so the caller can control the creation
            bool needToCloneObject = true;
            if (needToCloneObject)
            {
                Vehicle newObj = factory(source);
                if (newObj != null)
                {
                    // Now we have a new object to work with
                }
            }
        }
        [STAThread]
        public static void Main(string[] args)
        {
        }
    }
}

Media Richness Theory

Isn’t this a cool little theory?! It shows the richness of the communication – how personal, how interactive, how effective.

Let’s ask ourselves though, does effective mean more synchronous? does effective mean more asynchronous?

Compare Media Richness Theory to this chart by Wesley Fryer:

What other comparisons can be made? What framework do you find for thinking about these tools? How do you decide which one to use for which purpose? Have you seen any similar comparisons? Please share!

Isn’t this the million-dollar question? No? A couple hundred thousand, maybe? (Okay.  Maybe the answer is only worth a few hundred dollars.)

Whatever the value, a variation of this question has generated a terrific discussion in the ASTD LinkedIn group. The original post from Donna Gilliland, President of MOSTraining, Inc. read:

“Online Live Training: what challenges do you face? Have you started delivering training live online training yet? If so, which of the following tools to you use?”

She listed:

• GoToWebinar
• WebEx
• Telspan
• Others? 

Then she asked, “What do you find to be your greatest challenge in training live online?”

Several people chimed in, all of whom seemed to be focused on two key areas:

• Presenters’ skills
• Tools/technology

What’s missing here?!?

CONTENT!!!

Yes, I’ll keep preaching this. Yes, my face is blue from repeating it over and over. And no, I’m not tired of repeating myself quite yet.

Why is content so important?

Because if your content doesn’t match the delivery mode, it doesn’t matter how interesting, entertaining, adept, practiced, experienced or knowledgable your instructor/facilitator/trainer is, the online event will fail. Completely.

If your content doesn’t match the delivery mode, it doesn’t matter how many polls, chat and breakout rooms you use, how pretty your slides are, or whether you use phone or VOIP, the online event will fail. Utterly.

So I’ll say it again: your content needs to be presented in a way that enables your learners to learn. Sounds obvious, but failing to do this is the primary reason most online events fail.

Webinars are a great example. They’re easy to conduct and attend, relatively inexpensive, and everyone seems to be offering them. Even when they should be doing something else (see When A Webinar Is a Bad Idea).

Only after you’re sure you have decided on the best delivery mode for the content you’re training should you be thinking about how you’ll handle the technical side of things, and choose the instructor.

Period. End of discussion.

Now, if you’ll excuse me, I need to get some pink back into my face

Enjoying Distance Learning

Yes the thing – the thing to bring some emotion and enjoyment to the business of distance learning. Live online learning not only connects people, but is also a powerful aid to learning. How so! Using web conferencing software a teacher/facilitator has a vast array of tools to promote active learning and whether that be face to face or online at a distance there is a vast array of literature that extols the virtues of active learning. What tools say thee! Ok we have voice and video conferencing, text chat, whiteboard text and drawing tools, feedback icons such as ‘yes’, ‘no’ and raised hand (to ask a question), web browser sharing, quizzes and polls, file transfers and on the fly uploading of resources.

Now with some investment in time to understand how best to use the technology for teaching and learning, you’ll soon see how you can transform the hum drum educational experience of the distance learner.

Some Initial Reactions

I write these notes after completing an initial round of live online inductions using Wimba Live Classroom with my colleague Mellissa Phillips on the topic of myDmu and Blackboard, the main online learning services of my university DMU. These first set of month long inductions were not without some initial logging on difficulties which was disappointing as we were desperate to avoid irritating logging on problems. However for those postgraduate students that did logon and participate it appeared to be a welcome and enjoyable experience. Some brief comments (all positive) from those that attended included:

“Very interesting session, i am amazed by what technology is available and i think it will be a very good way of learning and communicating during the remainder of the course.”

“I thought the use of live on line tech was very good and there were no problems. Would like to see it used in discussion boards etc if poss”

Some Broad Lesson Learnt

Some good comments appreciating the value of this form of learning, but we still have work to do to improve this particular live online learning experience. The lessons we are learning are:

1. We have to keep working very hard to change the mindset of the vast majority of programme leaders and students who are unaware of the power of voice technology in distance learning. We hope at the end of this month long series of inductions to have gathered a body of evidence to support the value of this mode of learning and try gradually to move thinking and expectations on in this area.
2. Due to the struggle to get participants live online we are cramming too much into their first live online learning experience. We end up giving them a crash course on how to work in the new environment and then proceed to give the myDMU and Blackboard induction. Currently thinking this should be split due to the need to iron out initial technology problems that some students have.
3. You have to work hard to understand how each particular live online learning environment works. By this I mean that there are a vast array of web conferencing services to use, each one is setup differently – you have to understand how you can smoothly integrate the technology into your teaching aims. Big Big tip – to fully appreciate this whilst developing you should log in on two machines – one as admin/presenter and the other as participant. You can then see the effects of your intended interactions from the participant viewpoint (allowing you to shape and refine your approach).

The Technology Used

Knowing that this was for most students this was their first experience of this type of learning we restricted our use of technology to:

1. Voice conferencing
2. Text chatting
3. Web browser demonstrations
4. Links to web pages that held pre-recorded Camtasia video screencasts.
5. The students also completed some self study tasks during the class.

A Word on Participant Interaction

With regard to the level of participant interaction and use of the technology available on a scale of 1 to 5 I’d rate this just over three. With increased student familiarity and appreciation of the live online environment we can edge this more to 5 when devising classroom activities and interactions in the future.

Headline Grabbing Camtasia

Mentioned as a headline grabber Camtasia is undoubtedly King in the world of e-learning tools. This easy to use moving screen capture software, with brilliant automatic zoom focus technology is a must for any lecturer who spends hours and hours grabbing screenshots for the production of module guides. The video quality is excellent and once saved the source material can be produced in a variety of formats for use in a variety of situations. i.e. web, iPod, DVD. Educational versions can be picked up for £134and in my opinion should be subject to a site licence for any serious learning organization.

More on explanation and discussion on Camtasia and live online learning will follow soon in up and coming blog posts. Look out for them.

Today we have another sample MonoTouch program. This little program performs a synchronous web request. Though we’re using a UIWebView to display the results of the web request, the focus is on one way to perform a synchronous web request in MonoTouch. Note that HttpWebRequst and HttpWebResponse are .Net classes; don’t be looking in the Apple iPhone developer pages to find their descriptions.

Please do yourself and your iPhone users a favor: don’t use this technique except in a separate thread. If you do this on the main UI thread, you’ll lock it up until you get the response or it times out.

More details on building the main application and controller are available on the MonoTouch site, including sample programs and tutorials.

Update 10/10/09: Fixed code display.

Here’s the sample code:

/*
Copyright (c) 2009, Terry Westley

Copying and distribution of this file, with or without
modification, are permitted in any medium without royalty.
This file is offered as-is, without any warranty.
*/

using System;
using System.Drawing;
using System.IO;
using System.Net;
using System.Text;

using MonoTouch.Foundation;
using MonoTouch.UIKit;

namespace MT_SampleSyncWebRequest
{
    public class Application
    {
        static void Main (string[] args)
        {
            UIApplication.Main (args, null, "AppController");
        }
    }

    [Register ("AppController")]
    public class AppController : UIApplicationDelegate
    {
        UIWindow window;

        public override bool FinishedLaunching (
            UIApplication app, NSDictionary options)
        {
            // Create the main view controller
            var vc = new MainViewController ();

            // Create the main window and add main view
            // controller as a subview
            window = new UIWindow (
                UIScreen.MainScreen.Bounds);
            window.AddSubview(vc.View);

            window.MakeKeyAndVisible ();
            return true;
        }

        // This method is required in iPhoneOS 3.0
        public override void OnActivated (
            UIApplication application)
        {
        }
    }

    [Register]
    public class MainViewController : UIViewController
    {
        private UIWebView webView;

        public override void ViewDidLoad ()
        {
            base.ViewDidLoad ();

            webView = new UIWebView (new RectangleF (
                0, 0, this.View.Frame.Width,
                this.View.Frame.Height));
            this.View.AddSubview (webView);

            string url = "http://www.wolframalpha.com/iphone/";
            Uri uri = new Uri (url);

            // HttpWebRequest
            StringBuilder pageContent = new StringBuilder();
            try
            {
                HttpWebRequest request =
                    (HttpWebRequest)WebRequest.Create (uri);
                request.Method = "GET";

                HttpWebResponse response =
                    (HttpWebResponse)request.GetResponse();
                StreamReader sr = new StreamReader(
                    response.GetResponseStream(), Encoding.UTF8);
                string line;
                while ((line = sr.ReadLine ()) != null)
                {
                    pageContent.Append (line);
                }
                sr.Close ();
                response.Close ();
            }
            catch (Exception ex)
            {
                Console.WriteLine (ex);
            }

            webView.LoadHtmlString(
                pageContent.ToString(), new NSUrl(url));
            Console.WriteLine("Hey, switch to Simulator now");
        }
    }
}

.

Hi Gentle Readers

[{p ٧ ¬p} W {p ۸ ¬p}] ٧ significare aut crepare ٧ σημασία ἤ θόρυβος
or, in other words,«Speak if you have any words stronger than silence.» [Euripides]
So I keep silence for about one month in these pages (but a lot less on Twitter…) 

Google Reader new features

Announced by the official Google Reader Blog [Flurry of features for feed readers and Looking for great stuff to read], repeated like parrots by almost every Bloggers and Tweeters, I would like to avoid to add my voice in this Buzz & Noise to give you some Signal instead by shortly reviewing the new features of Google Readers (you can explore by yourself) and stress on the meaning of these feature from the perspective of Data Processing (“Web 1.x” or “It’s about data”) & People Connecting via the Social Medias (“Web 2.x” or “It’s about Poeple”)

No, the Rss/Atom is not dead and yes Google Reader gives you the opportunity to add new sources of information from other people and share your discoveries with the others in social medias including via your blog ( FYI: blogging is not dead …).
.
Here the new look of Google reader including the People You Follow feature:

An example of People You (“I”) Follow

The Sharing on Social Media feature:

Custom Sharing feature:

And finally the Bundle of feed you may create and share: (an example…)

.

.

The Cycle of Information and the Web

These new features gives to us the complete cycle of information production/consumption.

All Functions in the Information Cycle are present in the GReader features:

• Creators (content makers)
• Critics (comments, ratings, and reviews),
• Collectors (gathering, tagging and sharing contents),
• Joiners (connecting people to poeple via contents),
• Spectators (or pure consummers)
• Doers (because information is related to “energy” and lead to works on physical stuff…)
• Actors (because information is also related to communication and people relations…)

These functions are not exclusives to some peoples and not the others: each of us may, from time to time, be a creator or a pure consumer, or behave as critic or joiner… The only difference between the Internauts à la Web 2 is in the percentage of their time dedicated for each of these functions.

To keep things simple: presently, writing this article for you, I  behave as creator by making a new and valuable contents (I hope so!) but for the last month (august 2009) I was more critic, collector and joiner than creator and soon (if everything goes according to my plans) and doer and actor. Then I will return to the function of creator and, for sure, from time to time as a pure consumer. See the idea?

By the way, it’s not only about “Real Time” (synchronous applications) which are often chronophages but mainly about the new flexibility in the social functions of data processing and communications. People are no more maintained in a limited social function but have the opportunity to change from one function to another. This idea and it’s reality are more important, IMHO, than the so-called “Real Time” applications (a buzz word only ). Every creator know they must keep their most productive periods for themselves and their creation process”. Asynchronous applications are valuables tools as much as the “Real Time” ones.

Using Stylish Firefox add-on for your Google Reader (and more)

I can’t leave you without some Goodies so let me talk you about a very useful Firefox Add-on: Stylish.
Stylish let you fix ugly sites or customize the look of  any site or web applications such as Google Reader. There’s  an on-line repository at userstyles.org. Just few clicks and the chosen style is applied.

« Stylish is to CSS what Greasemonkey is to JavaScript »

Easy to use , just click on the icon in the Status bar of Firefox and check for a style sheet created for the web site you visit, select a style, apply it and check if it’s ok for you. Often you have many choices for a site so feel free to experiment. Styles are easy to apply and to disable.

Some screen captures for Google Reader:

.

and many more accessible at Userstyles.org via the Stylish Firefox Add-on.
Have fun!

I love discussions about how powerful a session or technique is. The great joy in discussing such things as this lies in the absence of any objective criteria. Everybody’s right, as there’s no definition of wrong.

There’s a few well established principles for session design. With nothing more than a gist of what behaviours are associated with each of the five broad bands of brainwave activity, sessions with a high probability of eliciting the desired effects can be created. There are no secrets required to write an alpha, theta or delta session that has every bit as much likelihood of ‘working’ as the most expensive downloads. Then, of course, there’s the realms of ‘psychoactive music’ – where the only rule that applies is that it must facilitate unusual perceptions.

A while ago I wrote a little program called ‘BrainForm’ that I posted on the Transparent user forum. If ability to twist the mind is taken as the highest priority, then BrainForm is capable of generating Very Powerful Sessions.

If you want to try a Very Very Powerful Session, find your old copy of BrainForm and set it up as shown. If you’re downloading BrainForm for the first time, make sure you read all the posts in the thread over there – BF is a bit fussy about installation and some of the other Transparent forum users were very, very helpful in ironing out bugs and finding workarounds.

When you’re all set up, hit ‘Generate’ and save the file somewhere you can find it. Once generated, find your file and play it in MediaPlayer or whatever.

Yup, that’s a 30 minute session. The general consensus regarding BrainForm sessions is that they aren’t pretty to listen to. Well, I challenge you to lay back with your AudioStrobe glasses on and the volume high (not silly high), and tough out the whole thirty minutes of the session generated with the settings above.

Used in this way, BrainForm is a very simple random music synthesizer. What I have found particularly engaging about these sessions is that my mind starts finding patterns in longer and longer segments of the sound, even though no such patterns are likely to be there. It’s quite hypnotic, much like looking for patterns in clouds. Another quirk is that sessions generated with the same settings differ only in random distribution, yet they can have quite different perceived rhythms.

The session is intense, insistent. Being both beta-based and demanding, it it the kind of session that could easily induce panic or anxiety in one prone to such things. Even with nothing particularly going on I find my stomach muscles tighten at times during these sessions. I believe its a very good session for thinking outside the square.

A BrainForm session is based on a stimulus pattern that I dreamed up while I was trying to imagine what I would really like to see and hear, what I thought I would find most stimulating. What I came up with was randomly generated pulse triplets. The three pulses within the triplet are spaced at the ‘target frequency’ – in this case between 12 and 20Hz. The pitch and amplitude of the pulses is proportional to the setting of the BF slider for that frequency. After a delay proportional to the last rate, another triplet is formed, at a frequency determined statistically from the spread of the BF sliders.

Sessions formed with BrainForm can be referred to as frequency independent sessions. There is no intention of entraining the brain to any particular frequency. What will happen is that a complex sequence of evoked potentials in the sensory regions will give all parts of the brain something to think about. By way of pure conjecture, I would venture that a whole brain highly active with asynchronous activity is probably more useful than one with isolated regions of synchronous activity. I often wonder what consideration is given to absolute potentials in EEG measurement – large volumes of asynchronous activity would not be seen as ripples in the EEG, but as an increased offset.

I hope you’ve now tried BrainForm and hated it. I get a real kick out of it, and an unanticipated side-effect of listening to these fast rise-time clicks is that my long standing tinnitus has diminished to barely a hiss.

In discussion of powerful sessions, we need to consider what we’re really saying. Methinks mostly what we mean is that there was something about a particular session that made it sufficiently engaging to make us stick with it for long enough to notice effects. It might be that the marketing carried significant weight for you. It might have been recommended by someone you trust. It might have a message that speaks to you. It might have the right aesthetics to appeal to you.

An observation I have made is that most people don’t like entrainment tracks to sound like entrainment tracks. The more skilfully a session designer can obscure the psychoactive elements without diminishing their effects too severely, the more popular the session is likely to be.

A common forum question is, ‘How quiet can I have the beats before they don’t work?” I ask the reciprocal question, “How loud can you have them before they become hopelessly annoying to you?” The evoked response to a stimulus is substantially proportional to the magnitude of the stimulus. Louder and sharper works better. But having you on a razor’s edge, teeth gritted, is going to work counter to anything but the most agressive pump-it-up session, so we do what we have to do. We trade raw power for palatability. We do that quite a lot in life – isn’t there something about “a softer easier way”?

During a session, keep in mind that there’s two quite distinct things going on. There’s the direct physiological effect of pulse stimulus to the visual and/or auditory centres. Then there’s your opinion, your judgement, your critique, your acceptance, your enjoyment, your intellectualisation of the sound and light experience. In between these poles is a whole gamut of perception to which we don’t usually pay attention.

It’s no secret that during my magickal days I made considerable use of entheogens to access unusual perceptions. Even now I make occasional use of the several very adequate herbals legally available in this country. The arrangement I have with these teacher plants is that whatever they show me, I try to find again without their help. Over the years I tried a lot of things, but the abyss between ordinary consciousness and that opened up by psychedelics has been too much for me to traverse bare-brained. AVS has provided the bridge, and with its help I can do most of the things that were previously only possible with spirit aid. Since using AVS many of the perspectives have become accessible to me in daily life.

I included the last paragraph for anyone who’s just come along to this blog, and hasn’t been reading my posts over on the Transparent or Mind Place forums for the last year or so. I’ve drawn my inspiration from many sources, and many of the more peculiar sessions that I have shared have come into existence through my efforts to emulate experiences I’ve had through shamanic or ritual techniques, with or without entheogens. One of my ambitions is to make these experiences accessible to others without the necessity for potentially hazardous, often illegal, substances and without resort to arcane and long-winded rituals. The universe perceived by a shaman is one stripped of both illusion and delusion. It is much easier to be accepting of what is when truly honest about oneself. Many of the sessions I write are intended to accompany introspection. Most ritual is little more than a symbolic representation of the self in macrocosm and microcosm, laid out in relation to the perceived universe, for inspection and reorganization. The most valuable function of ‘teacher plants’ is to nudge ego far enough into the background to allow a few self-truths to emerge.

AVS sessions can facilitate the deepest self-explorations. For myself, the most intense experiences arise when I’m deeply immersed in the unfamiliar. Any session that contains conventional musical elements contains objects of familiarity and interesting structures that my mind can attach to. Random sessions provide no such haven and the mind has no choice but to find it’s own way.

I hope these comments open the way for others to start experimenting with sessions that have little or no theoretical foundation other than a vague idea, such as, “I want to contemplate past influences, so I’ll target the theta range”. Forget about what anyone else might think, and write the session that speaks to you.

Have fun!!!

Cheers,
Craig

The field of Web conferencing software is growing at a breathtaking pace. In the summer of 1994 there were exactly two products in this category, both of them rather primitive freeware packages. Today there are well over 60 commercial and freeware products, many of them quite sophisticated, that support conferencing on the Web in one form or another.

With so many products available, the choice can seem overwhelming. But with a methodical approach, you’ll probably find that you can quickly whittle the list down to just a few candidates.

First, let’s define our terms. For our present purposes, conferencing is a form of group discussion that uses text messages stored on a computer as a communication medium. It does not include various types of real-time, or synchronous, communication, such as “chat rooms”, voice-based teleconferencing, or video conferencing.

A conferencing system is Web-based if it uses Web browsers and servers to provide most of its functionality. This is not as clear a distinction as it might sound. Most developers of conferencing software are hurrying to adapt their products to the Web, and the result is a lot of hybrid products that use the Web to a greater or lesser extent. Hence, the boundary between Web and non-Web conferencing software is a bit blurry.

For Info

I was talking tonight with Joni Dunlap about live, synchronous discussions in online classes.  I tend to go pretty structured so none of us (especially me) is second guessing whether to talk or listen.  I like to prompt  conversation with leads like- check out this video clip then talk about it, respond to this image, etc. When I think of the discussions that have been the most effective, I think the student led discussions last semester were probably the best of all. In reflecting on it I think that had to do mostly with the nature and the number of conversations with the leaders about what they need to think about to facilitate a good discussion… then that builds on itself as the leaders become participants in the next conversation and the quality of discussions grows exponentially throughout the semester.  I am excited to try breakout groups this semester… where teams go off and discuss or problem solve elements of an issue… then return for a new conversation to share and build on thinking from their small groups. It is a strategy that works amazingly face to face… I think synchronous conversations this way in Adobe Connect could be a really great way to bring multi-level conversations like this alive in the online classroom.

by Lorraine B. Elder

Dr. Judith V. Boettcher has written Teaching Online for the First Time — The Quick Guide. She lists ten best practices for designing and teaching a course, and most are spot on, with the possible exception of

Best Practice 5: Use both synchronous and asynchronous activities

Using both kinds of activities works only if your online students know up front that’s an expectation. Many students think online inherently means asynchronous, so be clear in your class description about whether synchronous activities are included in the course, and be sure to list the dates and times of the synchronous activities on a class preview page so students can figure out even before they register whether their school, work, and life schedules will permit them to be available at those times.

To Dr. Boettcher’s list, I’d add a few more implementation tips that the e-Learning Center has learned from years of working with faculty in preparing online and hybrid courses.

1. Don’t try to create an online course on the fly while you’re teaching it. You won’t like it and neither will your students.

If your in-person teaching style entails glancing at your notes—or not—a few minutes before class starts and then winging it by speaking extemporaneously, you’ll be tempted to approach online teaching the same way. Don’t do it. You’ll fumble with the technology (or it will go down at an inopportune time); you won’t have an adequate list of resources and supplemental materials available for your students; you’ll forget to include important details in your assignment instructions, confusing your students and sparking a flood of emails or discussion posts asking for clarification; and in an asynchronous course, your students will be irritated if they’re ready to proceed but you aren’t because you haven’t yet built out the course. They’re busy people, too, who don’t want you wasting their time.

2. Posting PowerPoint presentations online does not constitute an online course, no matter how many slides you include.

A bunch of bullet points out of context and lacking a speaker to fill in the details isn’t what students need. Neither are slides packed with overstuffed paragraphs. If you need to write paragraphs to convey your information, put them on a web page, not on a slide. Put the bullet points on web pages, too, and also write the information you would have said aloud in a face-to-face presentation. Or include an audio recording (with transcripts!) of what you would have said to accompany the slides.

Don’t expect students to intuit what you meant by your cryptic, one- or two-word bullets. What’s obvious to you—an expert— won’t be obvious to them—novices. Explain yourself.

I’ll have more to say on the evils of PowerPoint in a future blog post.

3. Make your course accessible to all students, including those who have disabilities.

It’s easy and desirable in an online course to include clips of rich instructional media, such as videos and audio. Be sure to include captioning or transcripts so that all students get the full benefit of the media without having to ask for special accommodations. Even students who don’t have disabilities often appreciate captions and transcripts. Also make sure your course can be navigated easily with a keyboard, not just a mouse, and check with your campus Disability Resources office to be sure that screen reader software can interpret your course material.

This work is licensed under a Creative Commons Attribution-Noncommercial 3.0 United States License.

“The next generation is responsible for its own soul; a man of genius is responsible to his peers, not to a studio full of uneducated and undisciplined coxcombs.”
T.S. Eliot

Coxcomb-a conceited dandy who is overly impressed by his own accomplishments (Princeton)

“Teachers shouldn’t be coxcombs nor should politicians try to squeeze the coxcombiness (I made it up a la Sussidio and Phil Collins) from schools with standardized tests that measure societal conceit. Also, don’t be a dandy as that is so 1920s.”
Michael Sean Gallagher

I have been doing some thinking of late on how technology has changed the face of education. Some will bemoan these changes, arguing that basic literacies and disciplined grounding in scholarship will be lost for the sake of technological acumen. Those of the opposite persuasion will argue that this very same technology allows us to push farther and faster than ever before, offering many more opportunities for genuine learning moments. The truth, as always, probably rests somewhere in between these schools of thought. This post will focus on the transformative effects of this technology on actual learning activities, those activities designed by teachers to elicit learning.

1. Education is omnipresent
This point illustrates itself. To think that the only education of any merit occurs in classrooms is ludicrous and has been dismissed almost exclusively. Granted, the opposite end of the spectrum will argue that very little actual education takes place in classrooms and that is equally unfounded. The only real question is what type of learning actually should take place in thee physical or digital environs.

Regardless, we live 99% of our lives outside of classrooms so to regulate that 99% to a compartment for living and not learning seems absurd. Learning is not turned off or on when one steps in and out of a classroom. Digital learning environments have illustrated the power of asynchronous learning, that learning done at the pace of the learner as opposed to a teacher guided activity. Most learning occurs in this asynchronous realm. But what type of learning? The self-directed kind obviously. Asynchronous is all about ingestion, analysis, synthesis and reflection. It is a perfect space for absorbing and personalizing learning; it is where the learning takes on the spiritual element. It becomes omnipresent, applied in all our daily facets, and with the reflection necessary in proscribed activities such as essay or blogs, it provides a significant augmentation of classroom activities.

In short, teachers should recognize that the majority of learning takes place outside of classrooms. Plan accordingly.

2. Assessment of learning is a fickle beast.
Yes, standardized testing and national metrics are necessary, but not necessarily for the sake of the learner. These are more benchmarks for the learning institutions. Basic literacies are indeed necessary; the ability to navigate society in any meaningful way is dependent on this preliminary type of education. It is skills based training at its finest and a basic building block of any sort of progress. This all applies to the synchronous learning activities.

But what of the asynchronous activities? What of the reflection, the synthesis, the discovery, the personalization of knowledge? How does a society, institution or individual assess the impact of education on the learner in question, especially when the learning is conducted at the pace and depth of the learner? It can have some standard elements, for sure. It can measure competence, an intelligence quotient. But IQ tests are not measures of anything other than IQ. Do you remember the last IQ class you had in secondary school? Of course not. You remember learning French, Calculas, Biology. You were never taught intelligence per se. But that is what we measure because that is the only measurable aspect of the classroom learning experience. Retention is valued over reflection. Retention, however, will not contribute in any measurable way to the betterment of society. Only reflective individuals will.

Assess the learning, make assessment as predictable as possible, and stay on task with assessment. All too often it veers into a measuring of some corollary activity wholey unrelated to the task at hand.

3. Learning takes place even with resistance/stubbornness/ego

The outward unwillingness to learn is not a disqualification from the learning process. The student in question is resisting for other reasons, most notably ego. By resisting do they identify themselves and that is an education in itself. Open defiance is disruptive to the learning process, but a general skepticism is critical to the reflective process. If I don’t question it, I can never make it fully my own. All religions ascribe to this line of questioning; doubt can be a perfectly valid intellectual response to a new idea. Recalcitrance is just an aberration of skepticism.

Also, learning is inherently an alteration of understanding and all too often our sense of self is buttressed by our view of the world (and especially our place in it.) Does Darwin refute religion? Most certainly not. Are two explanations for the same phenomena possible? Absolutely. Does an understanding of the barbarity/benevolence of my ancestors/country detract or augment my sense of worth? Well it shouldn’t, but it does. If the foundation of self is cast on such temporal stone, then it is bound to shift. Be sensitive to the student’s sense of self and the factors that play into that, but don’t let the pursuit of truth be hindered by that sense.

AJAX is stands for Asynchronous JavaScript And XML. It’s not a language such as Javascript, VBScript or anything, but it’s a collection of techniques that the developpers used for a long time.

AJAX can be used to update a web page continuesly or to update only a part of the web page. But, how this can happen? So to get an idea about this, you should consider about how the traditional model works.

So how the browser going to fetch data from the server? To understand this, let’s get an example of visiting Google.com. So when you want to visit google.com, you just enter google’s URL in your browsers address bar. When you hit “Enter”, the browser generate an request which is called as “HTTP Request“, and send that to the web server. When the server get this request, extract it, analyse it, and finally send back the required web page to the client’s browser. So this is happen everytime when you click a link or type a URL in the address bar.

Traditional Model

In the AJAX model, it is little bit different from the traditional model. Let’s understand this by an example. Imagine that you are viewing a photo gallery in some website. Thumbnails of all the photos are there on the page. When you click on one of the thumbnails, you can view the full-size image of that. If you are using the traditional model, the image will be loaded in a new page. But if you are using the AJAX model, you can see that image on the same page at some location without refreshing or navigating away from that page.

AJAX Model

So this is the basic idea of AJAX. AJAX has been so popular these days, and many websites use this for increase their user experience. Here are the some real world examples of AJAX.

1. GMail

   • If you are familiar with GMail, you can remember that, when you select a mail and click “Delete”, your mail will be deleted without refreshing the whole page. It’s AJAX.

2. Facebook

   • Facebook is one of main sites which use AJAX. In Facebook, you can update your status, delete a post from the wall, or send message without reloading the page. And when you enter someone’s name in your search box, you can see drop down list of similar names. That is also AJAX. The most interesting thing is, did you ever noticed that your news feed refreshes every 60 seconds? This shows the power of AJAX.

3. Google Maps

   • Google maps also uses AJAX for refreshing their maps when you navigate through or when you zoom them.

Oh… I forgot to tell you about another thing. Do you know what is meant by “Asynchronous“? OK, again an example. Your honey is gonna prepare something for the dinner. So she’s working hard and she does everything without bothering you. That is Synchronous. But one day, she asked you to cut potatoes while she’s doing other stuff. When you finished cutting, you alert her that you have finished cutting. That is Asynchronous.

In the Synchronous method, there is only one stream, that only the main-stream available (like herself). In asynchronous model, along with the main-steam, there are several sub-streams available (like your help to her). So in AJAX, it is asynchronous. i.e. data transfers happen, without disturbing your view.

So now the time to get ready for long run with AJAX…

A new pedagogy is being demanded by the 21^st century learners.  The traditional synchronous learning strategies, is now being ousted by new technologies.  With respects to social software via the internet, learners are opting to a more constructivist learning approach.  The concept of instructors banking information to learners while they passively receive the information is an example of “oppressed” pedagogy (Paulo Freire).

If we are all different, coming from different cultures, experiences and backgrounds, then why should we all be required to learn in the same way?  I cannot agree more that we need a more learner-focused system where the learners’ needs become the center of attention.