Skip to content


Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
tree: e94b67c6a0
Fetching contributors…

Cannot retrieve contributors at this time

1397 lines (978 sloc) 23.379 kb



Table of Contents

Programming in the Perl Object Environment

This is not a complete outline. While I've already begun writing, this outline is largely broken (Mostly between the third and sixth chapters), as its in mid-rework. I just wanted to see how it looked in the POE wiki's otl parser. If look at this and think I am missing or will miss something important, please let me know. (

<outline-head> &lt;/h1&gt;&lt;/h1&gt;

<H1><H1> &lt;/h1&gt;&lt;/h1&gt;

<H1><H1>Perl Object Environment &lt;/h1&gt;&lt;/h1&gt;

<H1>The introduction to this chapter should provide various information &lt;/h1&gt; <H1>reguaring what POE does. A simple over view of how it runs, and a &lt;/h1&gt; <H1>bit of information on how to use it. &lt;/h1&gt; <H1><H2>Why use POE? &lt;/h2&gt;&lt;/h1&gt;

<H1><H3>Its effective &lt;/h3&gt;&lt;/h1&gt;

<H1>POE Is much more efficient and effective than forking or &lt;/h1&gt; <H1>multithreading. &lt;/h1&gt; <H1><H3>Its efficient &lt;/h3&gt;&lt;/h1&gt;

<H1>Efficiency is often overlooked in favor of spending large amounts &lt;/h1&gt; <H1>of money on scaling server clusters in order to handle load and &lt;/h1&gt; <H1>decrease development time simultaniously. This is a fallacy, and &lt;/h1&gt; <H1>aside from that, POE can scale in ways nothing else can. &lt;/h1&gt; <H1><H3>Its cooperative &lt;/h3&gt;&lt;/h1&gt;

<H1>Because POE doesn't thread or fork, data is easier to manage. &lt;/h1&gt; <H1>Multithreading requires a very difficult to maintain combination of &lt;/h1&gt; <H1>locks on all shared data to avoid corruption. Forking doesn't &lt;/h1&gt; <H1>allow sharing of data after the new process is created, other than &lt;/h1&gt; <H1>via signals, alarms or pipes. This makes POE more powerful, and &lt;/h1&gt; <H1>easier to maintain. &lt;/h1&gt; <H1><H2>What POE does &lt;/h2&gt;&lt;/h1&gt;

<H1><H3>What POE was meant to be &lt;/h3&gt;&lt;/h1&gt;

<H1>POE was designed to be an object environment. It is, but its not &lt;/h1&gt; <H1>quite how it was original invisioned. Here we will cover just a &lt;/h1&gt; <H1>snippet of POE History. &lt;/h1&gt; <H1><H3>What POE is today &lt;/h3&gt;&lt;/h1&gt;

<H1>POE has become alot more than the Object/Event multitasking &lt;/h1&gt; <H1>environment it was intended to be. But in the same its alot less. &lt;/h1&gt; <H1>We're going to talk a little about the new directions POE is &lt;/h1&gt; <H1>taking as a flexable, extendable framework for scalable, event &lt;/h1&gt; <H1>based applications. &lt;/h1&gt; <H1><H3>What POE can and should do &lt;/h3&gt;&lt;/h1&gt;

<H1>Here we're going to just give an overview of what POE is capable &lt;/h1&gt; <H1>of, large multitasking environments, distributed applications, &lt;/h1&gt; <H1>extremely efficient usage of processing time, deligation of &lt;/h1&gt; <H1>resources. &lt;/h1&gt; <H1><H3>What POE can't and shouldn't do &lt;/h3&gt;&lt;/h1&gt;

<H1>POE has some limitations...but not many. &lt;/h1&gt; <H1><H5>+ Note &lt;/h5&gt;&lt;/h1&gt;

<H1>I'm actually considering pulling this out and maybe &lt;/h1&gt; <H1>summarizing the above subsection to be more along the &lt;/h1&gt; <H1>lines of "What POE can do for you". As this is sort of &lt;/h1&gt; <H1>covered below, in "Problems POE Creates" &lt;/h1&gt; <H1><H2>Problems POE Solves &lt;/h2&gt;&lt;/h1&gt;

<H1><H3>Effective use of processing time &lt;/h3&gt;&lt;/h1&gt;

<H1>POE deligates process time, giving events a chance to be performed &lt;/h1&gt; <H1>in order of priority, and from their in FIFO sequence. &lt;/h1&gt; <H1><H3>Time slicing &lt;/h3&gt;&lt;/h1&gt;

<H1>We'll touch base with the concept of time slicing that makes most &lt;/h1&gt; <H1>multitasking systems work. &lt;/h1&gt; <H1><H3>Wait without limits &lt;/h3&gt;&lt;/h1&gt;

<H1>Its quite easy to get a program to wait for input or wait for &lt;/h1&gt; <H1>another process to exit. But POE will wait for anything and &lt;/h1&gt; <H1>everything at once, and then prioritize timed events in addition &lt;/h1&gt; <H1>to this. &lt;/h1&gt; <H1><H2>Problems POE Creates &lt;/h2&gt;&lt;/h1&gt;

<H1><H3>Limitations in program design &lt;/h3&gt;&lt;/h1&gt;

<H1>Not all modules work well with POE, we will discuss this, and other things &lt;/h1&gt; <H1><H3>Nonblocking requirement &lt;/h3&gt;&lt;/h1&gt;

<H1>Its quite easy to stop a POE program from running. However you &lt;/h1&gt; <H1>have to think about this in order to keep a POE program running, &lt;/h1&gt; <H1>and in order to keep it running effectively. Its all to simple &lt;/h1&gt; <H1>for a bad program design to make POE less responsive. We'll &lt;/h1&gt; <H1>discuss this in this subsection. &lt;/h1&gt; <H1><H3>There's always an answer &lt;/h3&gt;&lt;/h1&gt;

<H1>Pretty much every problem presented by the induction of POE into &lt;/h1&gt; <H1>your programs design can be solved by a work around or other that &lt;/h1&gt; <H1>has been added to POE to solve this problem. &lt;/h1&gt; <H1><H1>Power Operating Environment &lt;/h1&gt;&lt;/h1&gt;

<H1>Here we will introduce various POE concepts and walk the reader through &lt;/h1&gt; <H1>the writing of thier first POE program. &lt;/h1&gt; <H1><H2>POE Sessions &lt;/h2&gt;&lt;/h1&gt;

<H1><H3>Explaination of Sessions &lt;/h3&gt;&lt;/h1&gt;

<H1>We'll provide a breif overview of what Sessions are, and what they &lt;/h1&gt; <H1>are for. We will dip lightly into how they work, but try not to &lt;/h1&gt; <H1>burry the reader in advanced concepts. &lt;/h1&gt; <H1><H4>Inline States &lt;/h4&gt;&lt;/h1&gt;

<H1>We'll introduce inline states, which are the pinnacle of POE &lt;/h1&gt; <H1>programming. We'll explain how they work and what they do, and &lt;/h1&gt; <H1>what they get. &lt;/h1&gt; <H1><H4>Session Heaps &lt;/h4&gt;&lt;/h1&gt;

<H1>This section should detail how the heaps work, why the heaps &lt;/h1&gt; <H1>are provided, and how you can access them. &lt;/h1&gt; <H1><H3>Creating a Session &lt;/h3&gt;&lt;/h1&gt;

<H1>Its time to introduce the create method. I'm opting to leave &lt;/h1&gt; <H1>'new' out of the book entirely, since it is never needed it is &lt;/h1&gt; <H1>only occasionally useful and I would like to see less code use it. &lt;/h1&gt; <H1><H5>+ Note &lt;/h5&gt;&lt;/h1&gt;

<H1>That is assuming Rocco agrees. &lt;/h1&gt; <H1><H4>State Arguments &lt;/h4&gt;&lt;/h1&gt;

<H1>We'll introduce the large number of arguements each session &lt;/h1&gt; <H1>reiceves, as well as why POE is implimented this way. &lt;/h1&gt; <H1><H4>Constants - a real psuedo hash &lt;/h4&gt;&lt;/h1&gt;

<H1>In this section we'll explain the constants which are exported &lt;/h1&gt; <H1>by the POE Session module, and how this greatly increases the &lt;/h1&gt; <H1>efficiency of inline states over a hash reference or argument &lt;/h1&gt; <H1>hashes. &lt;/h1&gt; <H1><H2>Introducing the POE Kernel &lt;/h2&gt;&lt;/h1&gt;

<H1><H3>What it does &lt;/h3&gt;&lt;/h1&gt;

<H1>The POE Kernel is the center of POE, respectively. In this &lt;/h1&gt; <H1>section we will provide a little introduction to how the POE &lt;/h1&gt; <H1>Kernel works, so our reader can understand a little of whats going &lt;/h1&gt; <H1>on. &lt;/h1&gt; <H1><H3>How it works &lt;/h3&gt;&lt;/h1&gt;

<H1>The POE Kernel watches signals, filehandles, and prepairs alarms &lt;/h1&gt; <H1>all at once. Here we will bring how this happens to light. &lt;/h1&gt; <H1><H3>Using the Kernel &lt;/h3&gt;&lt;/h1&gt;

<H1>We'll explain how to use the POE Kernel, in short. We wont really &lt;/h1&gt; <H1>go into great detail about its other features, we'll bring this in &lt;/h1&gt; <H1>later. &lt;/h1&gt; <H1><H4>->run &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>->post &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>->yield &lt;/h4&gt;&lt;/h1&gt;

<H1><H5>+ Note &lt;/h5&gt;&lt;/h1&gt;

<H1>Just the basics at first. &lt;/h1&gt; <H1><H2>Interaction between Kernel and Session &lt;/h2&gt;&lt;/h1&gt;

<H1>In this section we'll illustrate how the POE Kernel interacts with &lt;/h1&gt; <H1>its Sessions. Hopefully this will bring into light when a task &lt;/h1&gt; <H1>deserves its own Session, as well as explain some of the design &lt;/h1&gt; <H1>decisions of POE in general. &lt;/h1&gt; <H1><H3>Special States &lt;/h3&gt;&lt;/h1&gt;

<H1>POE Sessions treat states with a few specific names in a special &lt;/h1&gt; <H1>way. In this section, we will introduce these states and thier &lt;/h1&gt; <H1>workings. We will also explain why the reader should know about &lt;/h1&gt; <H1>atleast some of them from the begining. (Namely _start). &lt;/h1&gt; <H1><H4>_start &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>_stop &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>_child &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>_parent &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>_default &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>_signal &lt;/h4&gt;&lt;/h1&gt;

<H1><H3>Event Routing &lt;/h3&gt;&lt;/h1&gt;

<H1>We will also describe POE's event routing, both the low level &lt;/h1&gt; <H1>event routing performed by the POE Kernel and the high level event &lt;/h1&gt; <H1>routing which should be performed by most Components. Sure &lt;/h1&gt; <H1>references to the chapter on Components, somewhere around the &lt;/h1&gt; <H1>section which goes over writing your own components, for more &lt;/h1&gt; <H1>information on why higher level event routing should be used. &lt;/h1&gt; <H1><H1>Perl Overdrive Engine &lt;/h1&gt;&lt;/h1&gt;

<H1>Sooner than later we needed to bring this up, so this section will be &lt;/h1&gt; <H1>dedicated to the POE Wheel. This chapter will introduce the concept of the &lt;/h1&gt; <H1>Wheel. What its intentions are, and what the expected behavior of a Wheel &lt;/h1&gt; <H1>is. &lt;/h1&gt; <H1><H2>Nonblocking IO &lt;/h2&gt;&lt;/h1&gt;

<H1>This section will describe how POE's Wheels interact with the Kernel &lt;/h1&gt; <H1>to perform nonblocking IO on a higher level. &lt;/h1&gt; <H1><H2>Different Wheels for different environments &lt;/h2&gt;&lt;/h1&gt;

<H1>Like different tires for different terrain. &lt;/h1&gt; <H1><H3>ReadWrite Wheel &lt;/h3&gt;&lt;/h1&gt;

<H1>We must first illustrate the ReadWrite, possibly the most common, &lt;/h1&gt; <H1>POE Wheel. &lt;/h1&gt; <H1><H3>SocketFactory Wheel &lt;/h3&gt;&lt;/h1&gt;

<H1>And then SocketFactory Wheel and how to use it with the ReadWrite &lt;/h1&gt; <H1>wheel to do create sockets in a completely POE friendly manner. &lt;/h1&gt; <H1><H3>ListenAccept Wheel &lt;/h3&gt;&lt;/h1&gt;

<H1>Then while we're on topic the ListenAccept Wheel, and how you can &lt;/h1&gt; <H1>use it to work with Net:: and other modules which create thier own &lt;/h1&gt; <H1>sockets in a non-POE-friendly manner. &lt;/h1&gt; <H1><H3>FollowTail Wheel &lt;/h3&gt;&lt;/h1&gt;

<H1>A brief description of the FollowTail Wheel and maybe a multiple &lt;/h1&gt; <H1>log chaser example. &lt;/h1&gt; <H1><H3>Curses Wheel &lt;/h3&gt;&lt;/h1&gt;

<H1>The Curses Wheel and an example of how to use it to do simple &lt;/h1&gt; <H1>nonblocking keyboard input. &lt;/h1&gt; <H1><H3>Run Wheel &lt;/h3&gt;&lt;/h1&gt;

<H1>Then last but not least the Run Wheel. We'll provide an example of &lt;/h1&gt; <H1>how it can be used to do inter-process communication with a &lt;/h1&gt; <H1>programs children in a nonblocking form, while your program does &lt;/h1&gt; <H1>other things. &lt;/h1&gt; <H1><H2>POE Filters &lt;/h2&gt;&lt;/h1&gt;

<H1>This would be a good time to go over POE Filters and what thier &lt;/h1&gt; <H1>purpose is. And then go over the various filters. &lt;/h1&gt; <H1><H3>Line Filter &lt;/h3&gt;&lt;/h1&gt;

<H1>The line filter, the most common and often default should be &lt;/h1&gt; <H1>first. &lt;/h1&gt; <H1><H3>Block Filter &lt;/h3&gt;&lt;/h1&gt;

<H1>The block filter, and how it can be used for binary networking &lt;/h1&gt; <H1>protocols. &lt;/h1&gt; <H1><H3>Reference Filter &lt;/h3&gt;&lt;/h1&gt;

<H1>The reference filter and probably here, while we're on references, &lt;/h1&gt; <H1>we'll refer them to the the section on Application Servers and &lt;/h1&gt; <H1>IKC. &lt;/h1&gt; <H1><H3>Grep Filter &lt;/h3&gt;&lt;/h1&gt;

<H1>The clever and ultimately flexable Grep filter &lt;/h1&gt; <H1><H3>Map filter &lt;/h3&gt;&lt;/h1&gt;

<H1>The map filter and how it lets them get all down and dirty with &lt;/h1&gt; <H1>thier data. &lt;/h1&gt; <H1><H3>Stackable Filter &lt;/h3&gt;&lt;/h1&gt;

<H1>And then how to use several filters togeather, using the stackable &lt;/h1&gt; <H1>filter. &lt;/h1&gt; <H1><H1>POE Components &lt;/h1&gt;&lt;/h1&gt;

<H1>Now that we have the details out of the way, the reader should be familiar &lt;/h1&gt; <H1>with enough POE to write a Component or two. &lt;/h1&gt; <H1><H2>Component Oriented Programming &lt;/h2&gt;&lt;/h1&gt;

<H1>But first we must introduce the concept of the component. &lt;/h1&gt; <H1><H2>Component Designs &lt;/h2&gt;&lt;/h1&gt;

<H1>And why component based designs work for the programmer. &lt;/h1&gt; <H1><H3>Message Based Components &lt;/h3&gt;&lt;/h1&gt;

<H1>We should describe message based copmonents and how thier event &lt;/h1&gt; <H1>callbacks let you work seemlessly with another session who's &lt;/h1&gt; <H1>output you have to wait for. &lt;/h1&gt; <H1><H3>Session Based Components &lt;/h3&gt;&lt;/h1&gt;

<H1>As well as Session based components that allow you to build your &lt;/h1&gt; <H1>entire application around them. &lt;/h1&gt; <H1><H2>Writing your own components &lt;/h2&gt;&lt;/h1&gt;

<H1>It will describe how you can easily go about writing your own &lt;/h1&gt; <H1>components. &lt;/h1&gt; <H1><H3>Writing components from scratch. &lt;/h3&gt;&lt;/h1&gt;

<H1>How small an simple a component can be, and yet how much it can &lt;/h1&gt; <H1>break up your design and make it easier to manage. &lt;/h1&gt; <H1><H3>Writing components using components. &lt;/h3&gt;&lt;/h1&gt;

<H1>As well as how you would use other components to write things like &lt;/h1&gt; <H1>protocol specific daemons that build stand alone applications &lt;/h1&gt; <H1>using POE. Clients will be covered too of course. &lt;/h1&gt; <H1><H3>Component Conventions &lt;/h3&gt;&lt;/h1&gt;

<H1>Things people should consider when designing thier components, &lt;/h1&gt; <H1>such as inline state naming, high level event routing, how to go &lt;/h1&gt; <H1>about exporting constants and adding features to the array given &lt;/h1&gt; <H1>to states. Also interface considerations, and what ever else may &lt;/h1&gt; <H1>come up between now and writing this section..' &lt;/h1&gt; <H1><H1>User interfaces and POE &lt;/h1&gt;&lt;/h1&gt;

<H1>Now we will talk about using POE For user interfaces. We will go over how &lt;/h1&gt; <H1>we replace other event loops with POE loops, and how to do it with or &lt;/h1&gt; <H1>without an alternative POE Loop. &lt;/h1&gt; <H1><H2>POE and Tk &lt;/h2&gt;&lt;/h1&gt;

<H1>We'll talk about POE and Tk and how POE's custom Tk loop has been &lt;/h1&gt; <H1>designed to work seemlessly with Tk. &lt;/h1&gt; <H1><H2>POE and Gtk &lt;/h2&gt;&lt;/h1&gt;

<H1>We'll also talk about the Gtk event loop and how POE replaces it, as &lt;/h1&gt; <H1>well as how its signal and other handlers communicate. &lt;/h1&gt; <H1><H2>POE and Qt &lt;/h2&gt;&lt;/h1&gt;

<H1>Maybe by then there will be some Qt to cover, as that event loop &lt;/h1&gt; <H1>hasn't been addressed yet. &lt;/h1&gt; <H1><H2>POE and Curses &lt;/h2&gt;&lt;/h1&gt;

<H1>And then we'll talk about the down and dirty, using POE for Good old &lt;/h1&gt; <H1>Curses interfaces. &lt;/h1&gt; <H1><H3>POE and the Curses UI Toolkit &lt;/h3&gt;&lt;/h1&gt;

<H1>Someplace we might wish to mention the Curses UI Toolkit &lt;/h1&gt; <H1>adaptation. &lt;/h1&gt; <H1><H3>The Term Visual interface &lt;/h3&gt;&lt;/h1&gt;

<H1>We also should make mention of the very nice Term Visual &lt;/h1&gt; <H1>interface. &lt;/h1&gt; <H1><H2>POE and the xyz UI &lt;/h2&gt;&lt;/h1&gt;

<H1>As well as more information on how to make POE work with any old user &lt;/h1&gt; <H1>interface. How to go about circumventing foreign event loops to make &lt;/h1&gt; <H1>them use POE, as well as how to make POE use other event loops (also &lt;/h1&gt; <H1>when you can, when you should, and when you shouldn't take that &lt;/h1&gt; <H1>approach). &lt;/h1&gt; <H1><H1>Programming Over Easy &lt;/h1&gt;&lt;/h1&gt;

<H1>Now would be a good time to make a trip back into Networking to describe &lt;/h1&gt; <H1>it in possibly a little more detail, since our reader probably by now &lt;/h1&gt; <H1>wants to either make a client, a daemon, or never ever hear of POE again. &lt;/h1&gt; <H1>Hopefully not the latter :) &lt;/h1&gt; <H1><H2>Moving from IO::Select &lt;/h2&gt;&lt;/h1&gt;

<H1>We'll describe how to migrate IO::Select applications. &lt;/h1&gt; <H1><H2>Moving from Net::SomeModule &lt;/h2&gt;&lt;/h1&gt;

<H1>And we'll describe how to work with Net::SomeModule, as well as a few &lt;/h1&gt; <H1>of the components which can easily replace Net::SomeModule. &lt;/h1&gt; <H1><H2>Using POE for TCP &lt;/h2&gt;&lt;/h1&gt;

<H1>And we'll talk about TCP, for Clients and Servers. Using POE's &lt;/h1&gt; <H1>ReadWrite and SocketFactory wheel's, and daemonizing &lt;/h1&gt; <H1><H3>POE Clients &lt;/h3&gt;&lt;/h1&gt;

<H1><H3>POE Daemons &lt;/h3&gt;&lt;/h1&gt;

<H1><H3>Using TCP Components &lt;/h3&gt;&lt;/h1&gt;

<H1>And we'll discuss the components that make thier lives easier. As &lt;/h1&gt; <H1>well as the components which make thier lives a little harder to &lt;/h1&gt; <H1>achieve a slightly different ultimate goal. &lt;/h1&gt; <H1><H4>Client Components &lt;/h4&gt;&lt;/h1&gt;

<H1>Client Components &lt;/h1&gt; <H1><H4>Daemon Components &lt;/h4&gt;&lt;/h1&gt;

<H1>And Daemon Components. &lt;/h1&gt; <H1><H2>Using POE for UDP &lt;/h2&gt;&lt;/h1&gt;

<H1>And then we'll take a short trip into the land of UDP and POE. &lt;/h1&gt; <H1><H2>Using POE for DNS &lt;/h2&gt;&lt;/h1&gt;

<H1>But by this time, they're going to want to know about the DNS Client &lt;/h1&gt; <H1>Component, which should allow them to utilize some of their recently &lt;/h1&gt; <H1>aquired message based communication knowledge. &lt;/h1&gt; <H1><H1>Advanced Concepts &lt;/h1&gt;&lt;/h1&gt;

<H1><H2>NFA &lt;/h2&gt;&lt;/h1&gt;

<H1>Then we should describe the NFA State Machine. I will have to learn a &lt;/h1&gt; <H1>little bit more about it myself before I can write about it, I'm still &lt;/h1&gt; <H1>kind of in awe :) &lt;/h1&gt; <H1><H1>Proliferation Of Events &lt;/h1&gt;&lt;/h1&gt;

<H1>The introduction to this chapter will begin with explanations of what &lt;/h1&gt; <H1>distributing tasks is all about. Why we do it, why we often dont, and why &lt;/h1&gt; <H1>POE does a good job of this. &lt;/h1&gt; <H1><H2>Application Servers &lt;/h2&gt;&lt;/h1&gt;

<H1>Then we'll explain how to design application servers in POE. &lt;/h1&gt; <H1><H2>InterKernel Communication &lt;/h2&gt;&lt;/h1&gt;

<H1>Using InterKernel Communication, and the IKC Components. &lt;/h1&gt; <H1><H3>The IKC Server &lt;/h3&gt;&lt;/h1&gt;

<H1>We'll explain how the IKC Server works to seemelessly accept &lt;/h1&gt; <H1>instructions as through they came from inside the current Kernel. &lt;/h1&gt; <H1><H3>The IKC Client &lt;/h3&gt;&lt;/h1&gt;

<H1>And how the IKC Client works with the IKC Server to give &lt;/h1&gt; <H1>instructions to other Kernels. &lt;/h1&gt; <H1><H3>The IKC Responder &lt;/h3&gt;&lt;/h1&gt;

<H1>As well as How the responder can be used to generate responses &lt;/h1&gt; <H1>seemlessly like message based POE Components. &lt;/h1&gt; <H1><H3>Serialization &lt;/h3&gt;&lt;/h1&gt;

<H1>And how you can use whatever Serialization you want to transfer &lt;/h1&gt; <H1>the data, including something like YAML or Data::Dumper which are &lt;/h1&gt; <H1>a bit more legible for logging/debugging. And a small overview of &lt;/h1&gt; <H1>various available Serialization modules and languages. &lt;/h1&gt; <H1><H5>+ Note &lt;/h5&gt;&lt;/h1&gt;

<H1>Surely we will make references here back to Filter-Reference &lt;/h1&gt; <H1>mentioned earlier in the book &lt;/h1&gt; <H1><H3>Non POE Clients &lt;/h3&gt;&lt;/h1&gt;

<H1>We'll demonstrate how to use Non POE clients in places where its &lt;/h1&gt; <H1>not appropriate to use a POE client, but it is appropriate to &lt;/h1&gt; <H1>distribute your application. I think the example we should use is &lt;/h1&gt; <H1>a mod_perl application that must scale, we'll make POE distribute &lt;/h1&gt; <H1>all the work while the mod_perl program works as simply an outlet &lt;/h1&gt; <H1>for communicating with the browsers. &lt;/h1&gt; <H1><H2>Job Servers &lt;/h2&gt;&lt;/h1&gt;

<H1>We'll explain the more about much more Simple job servers which dont &lt;/h1&gt; <H1>use inter-kernel communication, but are implimented with more of a &lt;/h1&gt; <H1>simple TCP protocol for enqueuing jobs and returning thier &lt;/h1&gt; <H1>information. &lt;/h1&gt; <H1><H1>POE's Private Parts &lt;/h1&gt;&lt;/h1&gt;

<H1>And now we'll actually dig into the internals and more obscure parts of &lt;/h1&gt; <H1>POE. The point is the same as the recent abstractions, to make POE Easier &lt;/h1&gt; <H1>to extend. The goal is to document the Kernel abstractions promoting that &lt;/h1&gt; <H1>pretty much any problem concievable can be solved without actually &lt;/h1&gt; <H1>fiddling with the POE Kernel. &lt;/h1&gt; <H1><H2>POE's Loops &lt;/h2&gt;&lt;/h1&gt;

<H1>Such as the methods which are passed on to the POE Loops. &lt;/h1&gt; <H1><H3>Loop Contexts &lt;/h3&gt;&lt;/h1&gt;

<H1>It will describe how POE Selects which Loop to use. This should be &lt;/h1&gt; <H1>useful information for anyone who wants to write an additional POE &lt;/h1&gt; <H1>Loop to impliment something which doesn't currently exist. &lt;/h1&gt; <H1><H5>+ Note &lt;/h5&gt;&lt;/h1&gt;

<H1>Presumably by this time POE's new Loop Loading will be &lt;/h1&gt; <H1>working properly. &lt;/h1&gt; <H1><H3>Various POE Loops &lt;/h3&gt;&lt;/h1&gt;

<H1>It will also describe a number of alternative POE Loops that &lt;/h1&gt; <H1>already exist, and why they exist. Surely this section will have &lt;/h1&gt; <H1>plenty of references to the User Interface chapter. &lt;/h1&gt; <H1><H2>POE Drivers &lt;/h2&gt;&lt;/h1&gt;

<H1>In this section we'll be describing the more low level POE friendly IO &lt;/h1&gt; <H1>than most people would really ever use...the SysRW Driver, which is &lt;/h1&gt; <H1>used by most POE Wheels. &lt;/h1&gt; <H1><H2>POE Queues &lt;/h2&gt;&lt;/h1&gt;

<H1>We'll describe POE's Array Queue, and its FIFO organization of &lt;/h1&gt; <H1>similarly prioritized items. &lt;/h1&gt; <H1><H2>POE API &lt;/h2&gt;&lt;/h1&gt;

<H1>We'll describe the new POE::API interface in short, and its new found &lt;/h1&gt; <H1>ability to provide third party APIs into POE, without altering the &lt;/h1&gt; <H1>Kernel itself. &lt;/h1&gt; <H1><H2>POE Resource &lt;/h2&gt;&lt;/h1&gt;

<H1>And how it can interact with the new Resource abstractions, as well as &lt;/h1&gt; <H1>illustrate some of the current Resource abstractions available. &lt;/h1&gt; <H1><H3>Resource Aliases &lt;/h3&gt;&lt;/h1&gt;

<H1>Such as the managing of Session Aliases. &lt;/h1&gt; <H1><H3>Resource Events &lt;/h3&gt;&lt;/h1&gt;

<H1>We'll describe how abstracting the Event handling from the POE &lt;/h1&gt; <H1>Kernel simplifies its tasks &lt;/h1&gt; <H1><H3>Resource FileHandles &lt;/h3&gt;&lt;/h1&gt;

<H1>And all the other stuff that has no public interface. &lt;/h1&gt; <H1><H1>Appendix &lt;/h1&gt;&lt;/h1&gt;

<H1><H2>Quick Reference &lt;/h2&gt;&lt;/h1&gt;

<H1><H3>Kernel &lt;/h3&gt;&lt;/h1&gt;

<H1><H4>Methods &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>Exports &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>Debugging &lt;/h4&gt;&lt;/h1&gt;

<H1><H3>Session &lt;/h3&gt;&lt;/h1&gt;

<H1><H4>Methods &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>Constructor Options &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>Event Fields &lt;/h4&gt;&lt;/h1&gt;

<H1><H4>Predefined Event Names &lt;/h4&gt;&lt;/h1&gt;

<H1><H3>Loop &lt;/h3&gt;&lt;/h1&gt;

<H1><H3>API &lt;/h3&gt;&lt;/h1&gt;

<H1><H3>Resource &lt;/h3&gt;&lt;/h1&gt;

<H1><H3>Components &lt;/h3&gt;&lt;/h1&gt;

<H1>Established and stable POE components, brief listing &lt;/h1&gt; <H1><H4>POE::Component::IRC &lt;/h4&gt;&lt;/h1&gt;

<H1>IRC Client Component &lt;/h1&gt; <H1><H4>POE::Component::SNMP &lt;/h4&gt;&lt;/h1&gt;

<H1>SNMP Client Component &lt;/h1&gt; <H1><H4>POE::Component::Client::HTTP &lt;/h4&gt;&lt;/h1&gt;

<H1>Flexable and fast HTTP and HTTPs Client Component. &lt;/h1&gt; <H1><H4>POE::Component::Server::HTTP &lt;/h4&gt;&lt;/h1&gt;

<H1>POE Micro WebServer. &lt;/h1&gt; <H1><H4>POE::Component::Client::POP3 &lt;/h4&gt;&lt;/h1&gt;

<H1>Pop3 Client &lt;/h1&gt; <H1><H4>POE::Component::Client::Ping &lt;/h4&gt;&lt;/h1&gt;

<H1>Ping Client &lt;/h1&gt; <H1><H4>POE::Component::Pcap &lt;/h4&gt;&lt;/h1&gt;

<H1>libpcap Interface &lt;/h1&gt; <H1><H4>POE::Component::Client::TCP &lt;/h4&gt;&lt;/h1&gt;

<H1>Simplified TCP Client &lt;/h1&gt; <H1><H4>POE::Component::Server::TCP &lt;/h4&gt;&lt;/h1&gt;

<H1>Simplified TCP Server &lt;/h1&gt; <H1><H4>POE::Component::Client::DNS &lt;/h4&gt;&lt;/h1&gt;

<H1>A simple and effective DNS Client &lt;/h1&gt; <H1><H4>POE::Component::LaDBI &lt;/h4&gt;&lt;/h1&gt;

<H1>Nonblocking DBI Access &lt;/h1&gt; <H1><H4>POE::Component::IKC &lt;/h4&gt;&lt;/h1&gt;

<H1>InterKernel Communication Components &lt;/h1&gt; <H1><H5>POE::Component::IKC::Client &lt;/h5&gt;&lt;/h1&gt;

<H1>The Client &lt;/h1&gt; <H1><H5>POE::Component::IKC::Server &lt;/h5&gt;&lt;/h1&gt;

<H1>The Server &lt;/h1&gt; <H1><H5>POE::Component::IKC::Responder &lt;/h5&gt;&lt;/h1&gt;

<H1>State Handling &lt;/h1&gt; <H1><H5>POE::Component::IKC::Specifier &lt;/h5&gt;&lt;/h1&gt;

<H1>Event Specifier &lt;/h1&gt; <H1><H5>POE::Component::IKC::Freezer &lt;/h5&gt;&lt;/h1&gt;

<H1>Pure Perl Sterilization &lt;/h1&gt; <H1><H1>&lt;/outline&gt;&lt;/h1&gt; &lt;/h1&gt;</outline-head>
Jump to Line
Something went wrong with that request. Please try again.