Cooperative Task Management without Manual Stack Management or Event Driven Programming is not the opposite of Threaded Programming.
Event driven as well as multi-threaded programming has some advantages and disadvantages. This paper shows how the best features of event driven programming and multi-threaded programming can be used simultaneously.
Event driven programming model simplify concurrency issues by reducing opportunities for race conditions and dead locks but it requires manual stack management which is cumbersome. 
How event driven model simplifies concurrency issues?
Threaded programming model comes up with automatic stack management but it invites concurrency issues.
This paper uses event driven programming plus the automatic stack management to get the benefit of threaded programming and event driven programming model.
The gain in concurrency due to event driven model cannot be had without cumbersome manual stack management. By separating these two concerns, we were able to realize the 'best of both worlds'.
This paper focuses mainly on the two axes, task management and stack management, see figure 1
Task Management: One can often divide the work a program does into conceptually separate tasks: each task encapsulate a control flow, and all of the tasks access some common shared state.
Preemptive task management: wherein execution of tasks can interleave on uni-processor or overlap on multi-processors.
Serial task management: wherein each task runs to its completion before starting the next one.
Cooperative task management: In this approach, a task's code only yields control to other tasks at well defined points in the execution.
Does cooperative task management provide benefit on the multiprocessor system?
How can cooperative task management utilize the multiprocessor system?
How cooperative task management is different than serial or preemptive?
What are the overheads of adopting the cooperatinve task management? Why there is need to wrap around I/O library?

Stack Management: The common approach to achieve cooperative task management is to organize a program as a collection of event handlers.
Automatic Stack Management: herein, programmer expresses each task as a single procedure in the source language. Such a procedure may call functions that block on I/O operations such as disk or remote requests.
Manual Stack Management: In contrast, manual stack management requires a programmer to rip the code for any given task into event handlers that run to completion without blocking.
How event handler programming model leads to manual stack management?
What is a closure and how does it relates to the manual stack management?
http://en.wikipedia.org/wiki/Closure_(computer_science). 
How to convert a code wriiten in automatic stack management to manual stack management?
Issues with Manual Stack management:
Function Ripping: Now two or more language functions represent a single conceptual function.
Why is there need to rip the function into multiple functions?
Automatic Variables: Variables once allocated on the stack by the language must be moved into a new state structure stored on the heap to survive across yield points.
Control Structures: The entry point to every basic block containing a function that might block must be reachable from a continuation, and hence must be a seprate language-level function. 
How does control structre relate to function ripping?
Debugging stack: The call stack must be manually recovered when debugging, and manual optimizations of tail calls may make it unrecoverable.
What are manual optimizations of tail calls?
Stack Ripping: What is stack ripping and how does it relate to function ripping?
What's the advantage of manual stack management?
What's the drawback of automnatic stack management?
I/O management:  Does I/O management affect the cooperative programming model?
Conflict Management: How does it relate to task management?
Data Partitioning: How does it relate to synchronization?


Implementation:
This paper adopts the Hybrid approach where code using manual stack management as well as automatic stack management can be used with the help of software adaptors.
Hybrid Approach: In the windows OS, threads are scheduled preemptively and fibers are scheduled co operatively: Our implementation achieves cooperative task management by scheduling multiple fibers on a single thread; at any given time, only one fiber is active.
How does this implementation relate to event driven model?
Why there is need of multiple fibers? Is it to support Automatic Stack Management? See figue 2 and 3.
Why does scheduler runs on a seprate fiber? Is it to support event driven model?
How this paper does utilize the automatic stack management and manual stack management?
Both types of stack management code are scheduled by the same scheduler. How's this achieved?