text:
AnyEvent::Fork - everything you wanted to use fork() for, but couldn't
use AnyEvent::Fork;
->require ("MyModule")
->run ("MyModule::server", my $cv = AE::cv);
my $fh = $cv->recv;
This module allows you to create new processes, without actually forking them from your current process (avoiding the problems of forking), but preserving most of the advantages of fork.
It can be used to create new worker processes or new independent subprocesses for short- and long-running jobs, process pools (e.g. for use in pre-forked servers) but also to spawn new external processes (such as CGI scripts from a web server), which can be faster (and more well behaved) than using fork+exec in big processes.
Special care has been taken to make this module useful from other modules, while still supporting specialised environments such as App::Staticperl or PAR::Packer.
This module only creates processes and lets you pass file handles and strings to it, and run perl code. It does not implement any kind of RPC - there is no back channel from the process back to you, and there is no RPC or message passing going on.
If you need some form of RPC, you could use the AnyEvent::Fork::RPC companion module, which adds simple RPC/job queueing to a process created by this module.
And if you need some automatic process pool management on top of AnyEvent::Fork::RPC, you can look at the AnyEvent::Fork::Pool companion module.
Or you can implement it yourself in whatever way you like: use some message-passing module such as AnyEvent::MP, some pipe such as AnyEvent::ZeroMQ, use AnyEvent::Handle on both sides to send e.g. JSON or Storable messages, and so on.
There is an abundance of modules on CPAN that do "something fork", such as Parallel::ForkManager, AnyEvent::ForkManager, AnyEvent::Worker or AnyEvent::Subprocess. There are modules that implement their own process management, such as AnyEvent::DBI.
The problems that all these modules try to solve are real, however, none of them (from what I have seen) tackle the very real problems of unwanted memory sharing, efficiency or not being able to use event processing, GUI toolkits or similar modules in the processes they create.
This module doesn't try to replace any of them - instead it tries to solve the problem of creating processes with a minimum of fuss and overhead (and also luxury). Ideally, most of these would use AnyEvent::Fork internally, except they were written before AnyEvent:Fork was available, so obviously had to roll their own.
There are two traditional ways to implement parallel processing on UNIX like operating systems - fork and process, and fork+exec and process. They have different advantages and disadvantages that I describe below, together with how this module tries to mitigate the disadvantages.
A 5GB process needs 0.05s to fork on my 3.6GHz amd64 GNU/Linux box. This overhead is often shared with exec (because you have to fork first), but in some circumstances (e.g. when vfork is used), fork+exec can be much faster.
This module can help here by telling a small(er) helper process to fork, which is faster then forking the main process, and also uses vfork where possible. This gives the speed of vfork, with the flexibility of fork.
For example, modules or data files that are loaded will not use additional memory after a fork. Exec'ing a new process, in contrast, means modules and data files might need to be loaded again, at extra CPU and memory cost.
But when forking, you still create a copy of your data structures - if the program frees them and replaces them by new data, the child processes will retain the old version even if it isn't used, which can suddenly and unexpectedly increase memory usage when freeing memory.
For example, Gtk2::CV is an image viewer optimised for large directories (millions of pictures). It also forks subprocesses for thumbnail generation, which inherit the data structure that stores all file information. If the user changes the directory, it gets freed in the main process, leaving a copy in the thumbnailer processes. This can lead to many times the memory usage that would actually be required. The solution is to fork early (and being unable to dynamically generate more subprocesses or do this from a module)... or to use AnyEvent:Fork.
There is a trade-off between more sharing with fork (which can be good or bad), and no sharing with exec.
This module allows the main program to do a controlled fork, and allows modules to exec processes safely at any time. When creating a custom process pool you can take advantage of data sharing via fork without risking to share large dynamic data structures that will blow up child memory usage.
In other words, this module puts you into control over what is being shared and what isn't, at all times.
For example, it is not easy to find the correct path to the perl interpreter - $^X might not be a perl interpreter at all. Worse, there might not even be a perl binary installed on the system.
This module tries hard to identify the correct path to the perl interpreter. With a cooperative main program, exec'ing the interpreter might not even be necessary, but even without help from the main program, it will still work when used from a module.
Long running processes might run into problems when perl is upgraded and modules are no longer loadable because they refer to a different perl version, or parts of a distribution are newer than the ones already loaded.
This module supports creating pre-initialised perl processes to be used as a template for new processes at a later time, e.g. for use in a process pool.
For example, POSIX makes it almost impossible to fork from a multi-threaded program while doing anything useful in the child - in fact, if your perl program uses POSIX threads (even indirectly via e.g. IO::AIO or threads), you cannot call fork on the perl level anymore without risking memory corruption or worse on a number of operating systems.
This module can safely fork helper processes at any time, by calling fork+exec in C, in a POSIX-compatible way (via Proc::FastSpawn).
For example, when a program uses an event loop and creates watchers it becomes very hard to use the event loop from a child program, as the watchers already exist but are only meaningful in the parent. Worse, a module might want to use such a module, not knowing whether another module or the main program also does, leading to problems.
Apart from event loops, graphical toolkits also commonly fall into the "unsafe module" category, or just about anything that communicates with the external world, such as network libraries and file I/O modules, which usually don't like being copied and then allowed to continue in two processes.
With this module only the main program is allowed to create new processes by forking (because only the main program can know when it is still safe to do so) - all other processes are created via fork+exec, which makes it possible to use modules such as event loops or window interfaces safely.
This is where the wall of text ends and code speaks.
->require ("MyModule")
->run ("MyModule::worker, sub {
my ($master_filehandle) = @_;
# now $master_filehandle is connected to the
# $slave_filehandle in the new process.
MyModule might look like this:
package MyModule;
sub worker {
my ($slave_filehandle) = @_;
# now $slave_filehandle is connected to the $master_filehandle
# in the original process. have fun!
# create listener socket
my $listener = ...;
# create a pool template, initialise it and give it the socket
my $pool = AnyEvent::Fork
->require ("Some::Stuff", "My::Server")
->send_fh ($listener);
# now create 10 identical workers
for my $id (1..10) {
->send_arg ($id)
->run ("My::Server::run");
# now do other things - maybe use the filehandle provided by run
# to wait for the processes to die. or whatever.
My::Server might look like this:
package My::Server;
sub run {
my ($slave, $listener, $id) = @_;
close $slave; # we do not use the socket, so close it to save resources
# we could go ballistic and use e.g. AnyEvent here, or IO::AIO,
# or anything we usually couldn't do in a process forked normally.
while (my $socket = $listener->accept) {
# do sth. with new socket
This runs /bin/echo hi, with standard output redirected to /tmp/log and standard error redirected to the communications socket. It is usually faster than fork+exec, but still lets you prepare the environment.
/bin/echo hi
open my $output, ">/tmp/log" or die "$!";
->eval ('
# compile a helper function for later use
sub run {
my ($fh, $output, @cmd) = @_;
# perl will clear close-on-exec on STDOUT/STDERR
open STDOUT, ">&", $output or die;
open STDERR, ">&", $fh or die;
exec @cmd;
->send_fh ($output)
->send_arg ("/bin/echo", "hi")
->run ("run", my $cv = AE::cv);
my $stderr = $cv->recv;
When you want to be stingy with files, you can put your code into the DATA section of your module (or program):
use AnyEvent::Fork;
->eval (do { local $/; <DATA> })
->run ("doit", sub { ... });
sub doit {
... do something!
For single-file scripts it can be inconvenient to rely on external files - even when using a DATA section, you still need to exec an external perl interpreter, which might not be available when using App::Staticperl, Urlader or PAR::Packer for example.
Two modules help here - AnyEvent::Fork::Early forks a template process for all further calls to new_exec, and AnyEvent::Fork::Template forks the main program as a template process.
Here is how your main program should look like:
#! perl
# optional, as the very first thing.
# in case modules want to create their own processes.
use AnyEvent::Fork::Early;
# next, load all modules you need in your template process
use Example::My::Module
use Example::Whatever;
# next, put your run function definition and anything else you
# need, but do not use code outside of BEGIN blocks.
sub worker_run {
my ($fh, @args) = @_;
# now preserve everything so far as AnyEvent::Fork object
# in $TEMPLATE.
use AnyEvent::Fork::Template;
# do not put code outside of BEGIN blocks until here
# now use the $TEMPLATE process in any way you like
# for example: create 10 worker processes
my @worker;
my $cv = AE::cv;
for (1..10) {
$TEMPLATE->fork->send_arg ($_)->run ("worker_run", sub {
push @worker, shift;
This module can create new processes either by executing a new perl process, or by forking from an existing "template" process.
All these processes are called "child processes" (whether they are direct children or not), while the process that manages them is called the "parent process".
Each such process comes with its own file handle that can be used to communicate with it (it's actually a socket - one end in the new process, one end in the main process), and among the things you can do in it are load modules, fork new processes, send file handles to it, and execute functions.
There are multiple ways to create additional processes to execute some jobs:
This module has a "default" template process which it executes when it is needed the first time. Forking from this process shares the memory used for the perl interpreter with the new process, but loading modules takes time, and the memory is not shared with anything else.
This is ideal for when you only need one extra process of a kind, with the option of starting and stopping it on demand.
->require ("Some::Module")
->run ("Some::Module::run", sub {
my ($fork_fh) = @_;
When you need to have a bunch of processes that all execute the same (or very similar) tasks, then a good way is to create a new template process for them, loading all the modules you need, and then create your worker processes from this new template process.
This way, all code (and data structures) that can be shared (e.g. the modules you loaded) is shared between the processes, and each new process consumes relatively little memory of its own.
The disadvantage of this approach is that you need to create a template process for the sole purpose of forking new processes from it, but if you only need a fixed number of processes you can create them, and then destroy the template process.
my $template = AnyEvent::Fork->new->require ("Some::Module");
for (1..10) {
$template->fork->run ("Some::Module::run", sub {
my ($fork_fh) = @_;
# at this point, you can keep $template around to fork new processes
# later, or you can destroy it, which causes it to vanish.
This is relatively slow, and doesn't allow you to share memory between multiple processes.
The only advantage is that you don't have to have a template process hanging around all the time to fork off some new processes, which might be an advantage when there are long time spans where no extra processes are needed.
->require ("Some::Module")
->run ("Some::Module::run", sub {
my ($fork_fh) = @_;
This module exports nothing, and only implements a single class - AnyEvent::Fork.
There are two class constructors that both create new processes - new and new_exec. The fork method creates a new process by forking an existing one and could be considered a third constructor.
Most of the remaining methods deal with preparing the new process, by loading code, evaluating code and sending data to the new process. They usually return the process object, so you can chain method calls.
If a process object is destroyed before calling its run method, then the process simply exits. After run is called, all responsibility is passed to the specified function.
As long as there is any outstanding work to be done, process objects resist being destroyed, so there is no reason to store them unless you need them later - configure and forget works just fine.
Create a new "empty" perl interpreter process and returns its process object for further manipulation.
The new process is forked from a template process that is kept around for this purpose. When it doesn't exist yet, it is created by a call to new_exec first and then stays around for future calls.
Forks $proc, creating a new process, and returns the process object of the new process.
If any of the send_ functions have been called before fork, then they will be cloned in the child. For example, in a pre-forked server, you might send_fh the listening socket into the template process, and then keep calling fork and run.
Unlike the new method, this method always spawns a new perl process (except in some cases, see AnyEvent::Fork::Early for details). This reduces the amount of memory sharing that is possible, and is also slower.
You should use new whenever possible, except when having a template process around is unacceptable.
The path to the perl interpreter is divined using various methods - first $^X is investigated to see if the path ends with something that looks as if it were the perl interpreter. Failing this, the module falls back to using $Config::Config{perlpath}.
The path to perl can also be overridden by setting the global variable $AnyEvent::Fork::PERL - it's value will be used for all subsequent invocations.
Returns the process id of the process iff it is a direct child of the process running AnyEvent::Fork, and undef otherwise. As a general rule (that you cannot rely upon), processes created via new_exec, AnyEvent::Fork::Early or AnyEvent::Fork::Template are direct children, while all other processes are not.
Or in other words, you do not normally have to take care of zombies for processes created via new, but when in doubt, or zombies are a problem, you need to check whether a process is a diretc child by calling this method, and possibly creating a child watcher or reap it manually.
Evaluates the given $perlcode as ... Perl code, while setting @_ to the strings specified by @args, in the "main" package (so you can access the args using $_[0] and so on, but not using implicit shit as the latter works on @ARGV).
This call is meant to do any custom initialisation that might be required (for example, the require method uses it). It's not supposed to be used to completely take over the process, use run for that.
The code will usually be executed after this call returns, and there is no way to pass anything back to the calling process. Any evaluation errors will be reported to stderr and cause the process to exit.
If you want to execute some code (that isn't in a module) to take over the process, you should compile a function via eval first, and then call it via run. This also gives you access to any arguments passed via the send_xxx methods, such as file handles. See the "use AnyEvent::Fork as a faster fork+exec" example to see it in action.
Returns the process object for easy chaining of method calls.
It's common to want to call an iniitalisation function with some arguments. Make sure you actually pass @_ to that function (for example by using &name syntax), and do not just specify a function name:
$proc->eval ('&MyModule::init', $string1, $string2);
Tries to load the given module(s) into the process
Send one or more file handles (not file descriptors) to the process, to prepare a call to run.
The process object keeps a reference to the handles until they have been passed over to the process, so you must not explicitly close the handles. This is most easily accomplished by simply not storing the file handles anywhere after passing them to this method - when AnyEvent::Fork is finished using them, perl will automatically close them.
Example: pass a file handle to a process, and release it without closing. It will be closed automatically when it is no longer used.
$proc->send_fh ($my_fh);
undef $my_fh; # free the reference if you want, but DO NOT CLOSE IT
Send one or more argument strings to the process, to prepare a call to run. The strings can be any octet strings.
The protocol is optimised to pass a moderate number of relatively short strings - while you can pass up to 4GB of data in one go, this is more meant to pass some ID information or other startup info, not big chunks of data.
Enter the function specified by the function name in $func in the process. The function is called with the communication socket as first argument, followed by all file handles and string arguments sent earlier via send_fh and send_arg methods, in the order they were called.
The process object becomes unusable on return from this function - any further method calls result in undefined behaviour.
The function name should be fully qualified, but if it isn't, it will be looked up in the main package.
If the called function returns, doesn't exist, or any error occurs, the process exits.
Preparing the process is done in the background - when all commands have been sent, the callback is invoked with the local communications socket as argument. At this point you can start using the socket in any way you like.
If the communication socket isn't used, it should be closed on both sides, to save on kernel memory.
The socket is non-blocking in the parent, and blocking in the newly created process. The close-on-exec flag is set in both.
Even if not used otherwise, the socket can be a good indicator for the existence of the process - if the other process exits, you get a readable event on it, because exiting the process closes the socket (if it didn't create any children using fork).
If you want to write code that works with both this module and AnyEvent::Fork::Remote, you need to write your code so that it assumes there are two file handles for communications, which might not be unix domain sockets. The run function should start like this:
sub run {
my ($rfh, @args) = @_; # @args is your normal arguments
my $wfh = fileno $rfh ? $rfh : *STDOUT;
# now use $rfh for reading and $wfh for writing
This checks whether the passed file handle is, in fact, the process STDIN handle. If it is, then the function was invoked visa AnyEvent::Fork::Remote, so STDIN should be used for reading and STDOUT should be used for writing.
In all other cases, the function was called via this module, and there is only one file handle that should be sued for reading and writing.
Example: create a template for a process pool, pass a few strings, some file handles, then fork, pass one more string, and run some code.
my $pool = AnyEvent::Fork
->send_arg ("str1", "str2")
->send_fh ($fh1, $fh2);
for (1..2) {
->send_arg ("str3")
->run ("Some::function", sub {
my ($fh) = @_;
# fh is nonblocking, but we trust that the OS can accept these
# few octets anyway.
syswrite $fh, "hi #$_\n";
# $fh is being closed here, as we don't store it anywhere
# Some::function might look like this - all parameters passed before fork
# and after will be passed, in order, after the communications socket.
sub Some::function {
my ($fh, $str1, $str2, $fh1, $fh2, $str3) = @_;
print scalar <$fh>; # prints "hi #1\n" and "hi #2\n" in any order
This module has a limited API for use in child processes.
This function, which only exists before the run method is called, returns the arguments that would be passed to the run function, and clears them.
This is mainly useful to get any file handles passed via send_fh, but works for any arguments passed via send_xxx methods.
These methods might go away completely or change behaviour, at any time.
Flushes all commands out to the process and then calls the callback with the communications socket.
The point of this method is to give you a file handle that you can pass to another process. In that other process, you can call new_from_fh AnyEvent::Fork $fh to create a new AnyEvent::Fork object from it, thereby effectively passing a fork object to another process.
new_from_fh AnyEvent::Fork $fh
Takes a file handle originally rceeived by the to_fh method and creates a new AnyEvent:Fork object. The child process itself will not change in any way, i.e. it will keep all the modifications done to it before calling to_fh.
The new object is very much like the original object, except that the pid method will return undef even if the process is a direct child.
Now for some unscientific benchmark numbers (all done on an amd64 GNU/Linux box). These are intended to give you an idea of the relative performance you can expect, they are not meant to be absolute performance numbers.
OK, so, I ran a simple benchmark that creates a socket pair, forks, calls exit in the child and waits for the socket to close in the parent. I did load AnyEvent, EV and AnyEvent::Fork, for a total process size of 5100kB.
2079 new processes per second, using manual socketpair + fork
Then I did the same thing, but instead of calling fork, I called AnyEvent::Fork->new->run ("CORE::exit") and then again waited for the socket from the child to close on exit. This does the same thing as manual socket pair + fork, except that what is forked is the template process (2440kB), and the socket needs to be passed to the server at the other end of the socket first.
2307 new processes per second, using AnyEvent::Fork->new
And finally, using new_exec instead new, using vforks+execs to exec a new perl interpreter and compile the small server each time, I get:
479 vfork+execs per second, using AnyEvent::Fork->new_exec
So how can AnyEvent->new be faster than a standard fork, even though it uses the same operations, but adds a lot of overhead?
The difference is simply the process size: forking the 5MB process takes so much longer than forking the 2.5MB template process that the extra overhead is canceled out.
If the benchmark process grows, the normal fork becomes even slower:
1340 new processes, manual fork of a 20MB process
731 new processes, manual fork of a 200MB process
235 new processes, manual fork of a 2000MB process
What that means (to me) is that I can use this module without having a bad conscience because of the extra overhead required to start new processes.
This section lists typical problems that remain. I hope by recognising them, most can be avoided.
POSIX systems inherit file descriptors by default when exec'ing a new process. While perl itself laudably sets the close-on-exec flags on new file handles, most C libraries don't care, and even if all cared, it's often not possible to set the flag in a race-free manner.
That means some file descriptors can leak through. And since it isn't possible to know which file descriptors are "good" and "necessary" (or even to know which file descriptors are open), there is no good way to close the ones that might harm.
As an example of what "harm" can be done consider a web server that accepts connections and afterwards some module uses AnyEvent::Fork for the first time, causing it to fork and exec a new process, which might inherit the network socket. When the server closes the socket, it is still open in the child (which doesn't even know that) and the client might conclude that the connection is still fine.
For the main program, there are multiple remedies available - AnyEvent::Fork::Early is one, creating a process early and not using new_exec is another, as in both cases, the first process can be exec'ed well before many random file descriptors are open.
In general, the solution for these kind of problems is to fix the libraries or the code that leaks those file descriptors.
Fortunately, most of these leaked descriptors do no harm, other than sitting on some resources.
Normally, AnyEvent::Fork does start new processes by exec'ing them, which closes file descriptors not marked for being inherited.
However, AnyEvent::Fork::Early and AnyEvent::Fork::Template offer a way to create these processes by forking, and this leaks more file descriptors than exec'ing them, as there is no way to mark descriptors as "close on fork".
An example would be modules like EV, IO::AIO or Gtk2. Both create pipes for internal uses, and Gtk2 might open a connection to the X server. EV and IO::AIO can deal with fork, but Gtk2 might have trouble with a fork.
The solution is to either not load these modules before use'ing AnyEvent::Fork::Early or AnyEvent::Fork::Template, or to delay initialising them, for example, by calling init Gtk2 manually.
init Gtk2
This only applies to users of AnyEvent::Fork:Early and AnyEvent::Fork::Template, or when initialising code creates objects that reference external resources.
When a process created by AnyEvent::Fork exits, it might do so by calling exit, or simply letting perl reach the end of the program. At which point Perl runs all destructors.
Not all destructors are fork-safe - for example, an object that represents the connection to an X display might tell the X server to free resources, which is inconvenient when the "real" object in the parent still needs to use them.
This is obviously not a problem for AnyEvent::Fork::Early, as you used it as the very first thing, right?
It is a problem for AnyEvent::Fork::Template though - and the solution is to not create objects with nontrivial destructors that might have an effect outside of Perl.
Native win32 perls are somewhat supported (AnyEvent::Fork::Early is a nop, and ::Template is not going to work), and it cost a lot of blood and sweat to make it so, mostly due to the bloody broken perl that nobody seems to care about. The fork emulation is a bad joke - I have yet to see something useful that you can do with it without running into memory corruption issues or other braindamage. Hrrrr.
Since fork is endlessly broken on win32 perls (it doesn't even remotely work within it's documented limits) and quite obviously it's not getting improved any time soon, the best way to proceed on windows would be to always use new_exec and thus never rely on perl's fork "emulation".
Cygwin perl is not supported at the moment due to some hilarious shortcomings of its API - see IO::FDPoll for more details. If you never use send_fh and always use new_exec to create processes, it should work though.
AnyEvent::Fork itself cannot generally be used in subprocesses. As long as only one process ever forks new processes, sharing the template processes is possible (you could use a pipe as a lock by writing a byte into it to unlock, and reading the byte to lock for example)
To make concurrent calls possible after fork, you should get rid of the template and early fork processes. AnyEvent::Fork will create a new template process as needed.
undef $AnyEvent::Fork::EARLY;
undef $AnyEvent::Fork::TEMPLATE;
It doesn't matter whether you get rid of them in the parent or child after a fork.
AnyEvent::Fork::Early, to avoid executing a perl interpreter at all (part of this distribution).
AnyEvent::Fork::Template, to create a process by forking the main program at a convenient time (part of this distribution).
AnyEvent::Fork::Remote, for another way to create processes that is mostly compatible to this module and modules building on top of it, but works better with remote processes.
AnyEvent::Fork::RPC, for simple RPC to child processes (on CPAN).
AnyEvent::Fork::Pool, for simple worker process pool (on CPAN).
Marc Lehmann <firstname.lastname@example.com>
To install AnyEvent::Fork, copy and paste the appropriate command in to your terminal.
cpanm AnyEvent::Fork
CPAN shell
perl -MCPAN -e shell
install AnyEvent::Fork
For more information on module installation, please visit the detailed CPAN module installation guide.


text:
NEW YORK — Encouraging signs from two of the most important zones of the world economy, the powerhouse of China and the debt-burdened countries of Europe, drove the Dow Jones industrial average up 181 points Thursday, its second-biggest gain this year.
China's central bank reported a surprising jump in loans in March. That eased concerns about a sudden slowdown in the Chinese economy, whose growth has helped pull the globe out of recession.
Italy's government easily sold $6.4 billion in bonds to investors. After the auction, borrowing rates for Italy fell, European stock indexes reversed earlier declines and worries about the continental debt crisis eased, at least for the day.
"European governments have a mountain of debt coming due early this year," said John Canally, investment strategist at LPL Financial in Boston. "Some of what you're seeing today in markets is a bit of relief that they're working through it."
In New York, the Dow Jones industrial average climbed 1.4 percent to close at 12,986.58. It was the Dow's biggest jump since March 13 and put the average within sight of clearing 13,000 again.
After the market closed, Google reported earnings that were ahead of analysts' estimates and said it would issue a new class of non-voting stock to shareholders. Google rose 0.5 percent in aftermarket trading.
On Wednesday the stock market snapped out of a five-day slump, its longest and deepest of the year. Investors were worried about European debt, slower job growth and the Federal Reserve's resistance to taking further steps to boost the economy.
"I think the fear was overdone," said Scott Brown, chief economist at Raymond James. "This is the manic nature of the stock market. The sentiment seems to shift back and forth day by day. Either the economy is booming or it's completely falling apart."
In other trading, the Standard &Poor's 500 index rose 18.86 points, 1.4 percent, to 1,387.57. The Nasdaq composite index gained 39.09 points, 1.3 percent, to 3,055.55.
Materials companies led the S&P 500 higher, with energy and industrial stocks close behind. Hewlett-Packard gained 7.2 percent, the best in the Dow, after a study reported that shipments of personal computers unexpectedly rose by almost 2 percent at the start of the year.
The U.S. trade deficit shrank in February to $46 billion, a four-month low, as exports hit an all-time high. The shrinking trade deficit raised the possibility that the economy grew faster in the first quarter than previously expected.
U.S. stocks opened higher despite a rise in weekly unemployment claims. The Labor Department reported that applications for unemployment benefits jumped to 380,000 last week, the highest in two months.
To Canally, the stock market's two-day rally looks fragile. "We're only a few bad earnings reports and a bad government debt auction in Europe from another sharp sell-off," he said.
Among stocks making big moves:
— Avid Technology Inc. plunged 17 percent. The maker of equipment for recording music and video said it expects to post a loss in the first quarter, a result of weaker demand from amateur musicians and DJs.
— McKesson Corp. rose 3.9 percent after reporting that the Department of Veteran Affairs agreed to keep McKesson as its main drug supplier. The VA runs one of the country's largest health care systems.
— Tractor Supply Co. jumped 6.1 percent after its quarterly sales topped $1 billion for the first time beating Wall Street's estimates. The retailer of pig feed, power tools and an array of other products raised its full-year earnings outlook.
Talk to us
- You can tell us about news and ask us about our journalism by emailing firstname.lastname@example.com or by calling 425-339-3428.
- If you have an opinion you wish to share for publication, send a letter to the editor to email@example.com or by regular mail to The Daily Herald, Letters, P.O. Box 930, Everett, WA 98206.
- More contact information is here.

subset: commoncrawl


text:
If you've ever spent any time in Japan, you've seen them: big black buses blaring right-wing propaganda. And today, you're going to see an entire fleet of them.
If Japanese itasha enthusiasts gather, Japanese right-wingers do, too. Here, it was also to mark Japan's creation. This weekend, that's exactly what happened.
Feb. 11 is National Foundation Day, the day that the country's mythic first emperor, Jimmu, ascended to the throne. Jimmu is believed to have descended from Amaterasu, the Sun Goddess.
It's the stuff of legends (and the video game Okami), and the day was used in the past to whip up nationalism. Today, it's been stripped of its patriotic fervor—just don't tell these folks who showed up in Kashihara, Nara, where Emperor Jimmu, is supposedly buried.
Dubbed "gaisensha" (街宣車) or "propaganda trucks" in Japanese, the vehicles blast right-wing slogans and songs. The vehicles are intimidating—even to regular Japanese folks. Like anywhere, loving one's country is fine, but extreme patriotism can be frightening.
While Japan does have noise pollution laws, it also has free speech laws. These vans are able to get the same licenses that allow political parties, and even religious groups (hello Japanese Christians!), to drive around and broadcast their opinions.
These right-wing groups, or uyoku dantai (右翼団体) as they're called in Japanese, have existed in Japan since the country opened itself to the West. They are not mainstream. Some members are connected to organized crime—and some of them are not even Japanese citizens, but Japanese-Koreans, or Zainichi Koreans. Wikipedia has a list of groups considered to be uyoku dantai.
As Japanese website Gigazine pointed out, it's fairly normal to see these big black buses patrolling the city streets, blaring propaganda. However, this past weekend gave a rare chance to see an entire parking lot full of them.
In year's past, gaisen were mostly huge buses, but due to new automobile emissions regulations, they are getting smaller—mini-vans and even hybrids are not unheard of. And how about those Japanese right-wingers driving around in American cars?
Have a look at the propaganda mobiles. Photos courtesy of Japanese site Gigazine.
街宣車が大集合している橿原神宮の紀元祭に行ってみました [Gigazine]


text:
Aceves improves in latest batting practice session
FORT MYERS, Fla. -- Unlike his mysterious session with hitters on Sunday, there was no mistaking the intensity displayed by righty Alfredo Aceves as he threw batting practice on Wednesday.
The righty looked sharp, and engaged, from his first pitch.
"He had a very good day today -- focused, good effort level," said manager John Farrell. "He had a good work day."
As for what took place on Sunday, when Aceves came out lobbing the ball?
"It was just miscommunication. That's all it was," Aceves said. "I apologized for that and now we're on track."


text:
This is an archived article that was published on sltrib.com in 2014, and information in the article may be outdated. It is provided only for personal research purposes and may not be reprinted.
Torture is immoral, illegal and irreconcilable with this nation's most cherished values. If defenders of the CIA's "enhanced interrogation" program disagree, they should come out and say so. Instead, they blow smoke.
Sexist smoke, at that: Former CIA Director Michael Hayden said Sunday that Sen. Dianne Feinstein, D-Calif., is being "emotional" rather than "objective" as the intelligence committee, which Feinstein heads, moves toward release of a comprehensive report on CIA detention and torture during the George W. Bush administration.
Feinstein coolly responded that the report is indeed "objective, based on fact, thoroughly footnoted, and I am certain it will stand on its own merits. ... The only direction I gave staff was to let the facts speak for themselves."
Those facts, from what we know so far, are appalling.
Feinstein's committee voted 11-3 last week to declassify the report's 400-page executive summary, with ranking Republican member Saxby Chambliss of Georgia and several of his GOP colleagues joining the Democratic majority.
President Obama will face renewed pressure from the torture program's defenders to quash the whole thing, and it may be months before even the summary is publicly released.
It is unclear whether the full 6,000-page report will ever be declassified.
Forgive me for getting emotional, but this is an outrage.
It was Justice Louis D. Brandeis who remarked that "sunlight is said to be the best of disinfectants."
Torture is a stain on this nation's honor that can only be bleached away by full exposure. Feinstein's committee spent years finding out what really happened. I should have a right to know what my government did in my name.
The Washington Post last week quoted unnamed sources as saying the Senate report concludes that the CIA "misled the government and the public" about the torture program.
According to the Post, the agency downplayed the "severity" of its interrogation methods, overstated the significance of some prisoners and took credit for information that detainees had actually surrendered under legal, non-coercive questioning.
These leaked disclosures prompted another round of the endless "Does torture work?" debate. This is precisely what the defenders of torture want us to focus on, since it keeps us away from the central issue.
Jose Rodriguez Jr., who headed the CIA's National Clandestine Service and ran the program of clandestine detention and harsh interrogation, wrote in the Post that the undertaking "produced critical intelligence that helped decimate al-Qaida and save American lives."
Rodriguez specifically defends the CIA's treatment of an al-Qaida operative known as Abu Zubaida, who was subjected to waterboarding a form of torture that involves simulated drowning a total of 83 times.
But according to the Post, the Senate report establishes that most of the useful information that came from Abu Zubaida was extracted by an FBI interrogator using normal techniques before the CIA whisked the man away for waterboarding.
Ultimately, the debate about torture's effectiveness is a waste of time because neither side can definitively prove its case. Let's assume a detainee gave up a crucial bit of information after, say, 37 sessions of waterboarding. Should interrogators expect that another 37 sessions of waterboarding will produce another nugget of intelligence? If so, why stop? Wouldn't it be logical, then, to torture every prisoner until he or she dies?
But can the defenders of "enhanced interrogation" point to a single piece of information obtained under torture and say, with certainty, that it couldn't have been extracted any other way? No, they can't.
This is an argument about worldviews, not about facts, and it ignores the heart of the matter. The reason to fully examine the CIA's torture program isn't that it was ineffective. It's that it was immoral.
Torture is also illegal under U.S. and international law, and while Bush administration lawyers produced opinions sanctioning the practice, those who were involved are clearly worried about their potential exposure. It was Rodriguez who ordered the destruction of videotapes recording the interrogations of Abu Zubaida and another detainee, which kept them out of the hands of nosy Senate investigators.
The CIA wasn't able to destroy all the evidence, though. Among many unanswered questions, I want to know whether trained medical personnel physicians, psychologists attended the torture sessions. I'm sure the relevant professional associations and licensing boards would like to know as well.
The report is written. Only when Feinstein in her cool and unemotional way gets to share it with the nation can we begin to put this most hideous of episodes behind us.


text:
LSU Continues Chick-fil-A Bowl Dominance, 38-3
ATLANTA — Playing in what's become its dome away from home, the LSU football team lived up to its defending national champion moniker. The Tigers dominated No. 14 Georgia Tech with the school's largest first-half output in bowl history to win, 38-3, on Wednesday at the Georgia Dome.
LSU (8-5), which lost 5-of-8 games to end the 2008 regular season, played a complete game and showed the nation what they're made of against the overmatched Yellow Jackets.
The Tigers improved to 5-0 in the Chick-fil-A Bowl and have not allowed a touchdown its past two appearances. Four of those wins came in the Georgia Dome, while LSU has a 3-1 record in the SEC Championship game also played in the arena.
It was the 700th win in the history of LSU football.
LSU took a 7-3 lead into the second quarter and added 28 points before the half. The game was all but over when the Tigers went to the lockerroom leading 35-3. The school's previous best half in a bowl was 34 points against Illinois in the 2002 Sugar Bowl.
Special teams plays and the again-redeemed Tigers' defense were key, as Georgia Tech (9-4) fumbled twice, threw an interception, and turned the ball over on downs four times as its run-oriented couldn't overcome the LSU advantage on the scoreboard throughout the game.
Falling behind, the Yellow Jackets had no choice but to attempt six fourth-down conversions, converting only two.
Starting for second time, LSU freshman quarterback and Offensive Most Outstanding Player Jordan Jefferson was nearly flawless in the first 30 minutes. After starting 11-of-12, he finished 16-of-25 passing for 142 yards including a 25-yard touchdown to tight end Richard Dickson that gave LSU a 28-3 lead late in the second quarter and sealed Georgia Tech's fate.
LSU's rushing attack also lived up to its billing, as the Tigers' All-SEC running back Charles Scott scored his team's first three touchdowns (2, 4 and 1-yard) and moved into second place in the school's single-season rushing TD list with 18. Scott finished with 15 carries for 65 yards. The Tigers netted 161 yards on 35 carries.
Running back Keiland Williams added five runs for 42 yards and a 17-yard touchdown, while Jefferson had nine carries for 33 yards.
Dickson was Jefferson's favorite target with five catches for 50 yards and a touchdown. Wide receiver Brandon LaFell had two catches for 26 yards, and had an 86-yard score called back in the fourth quarter.
LSU's defense also answered its critics, bottling the Yellow Jackets' potent attack. The three points allowed was the fewest allowed to a ranked opponent since its 2005 Chick-fil-A Peach Bowl win over No. 9 Miami (40-3), and it was the fewest scored by Georgia Tech in its bowl history.
Linebacker Perry Riley was named the defensive Most Outstanding Player after recording 11 tackles.
"I think the turning point in the game was when we lined it up and kicked it off," said Georgia Tech coach Paul Johnson. "We got outplayed. We got outcoached. It was a good beating."
Georgia Tech, which entered the game with 282.3 rushing yards per game, was held to only 164.
Yellow Jackets starting quarterback Josh Nesbitt was unable to lead his team into the Tigers endzone. He completed only 8-of-24 passes for 150 yards with an interception, while rushing 16 times for 62 net yards.
Atlantic Coast Conference Player of the Year, running back Jonathan Dwyer, ran 10 times for 67 yards to lead his team. Thirty-nine of those yards came on a fourth-quarter meaningless run. Running back Roddy Jones added nine carries for 32 yards.
The Tigers lost the coin toss, electing to receive the opening kickoff. LSU took possession at the 40-yard line when Georgia Tech placekicker Scott Blair's kick rolled out of bounds at the 5. Scott ran over a pair of defenders on the first play from scrimmage for 13 yards, a sign of things to come for the Tigers offensive attack that struggled mightily toward the end of the season.
Jefferson completed passes of 10 and 11 yard to wide receivers Jared Mitchell and Terrance Toliver. A 13-yard catch by Dickson put the Tigers in a first-and-goal situation at the Yellow Jackets' 9. Two plays later, Scott scored the first of three first-half rushing touchdowns from seven yards out.
LSU led 7-0 with 11:58 to play in the first quarter.
Georgia Tech, known for its spread offense and its triple-option running attack, went to the air on three of its first four plays. A 40-yard pass from Nesbitt to Dwyer out on a wheel route out of the backfield moved Georgia Tech into LSU territory at the 40. However, they were stopped and forced to punt from the 43.
Georgia Tech defensive end Derrick Morgan went untouched to sack Jefferson on the next possession and LSU went three-and-out. Georgia Tech took over at its 33 with 8:08 to play in the first quarter, and drove to the LSU 7 before being stopped. A 19-yard option run by Jones allowed Georgia Tech to cross the midfield line, and Georgia Tech overcame a first-and-25 with three-straight 10-yard gains to the LSU 13.
The 7:05 drive ended with a 24-yard field goal by Blair with 1:03 left in the quarter. Tech trailed 7-3.
LSU took advantage of a roughing the passer personal foul to move into Georgia Tech territory. A third-down conversion by Scott setup a 20-yard catch by Brandon LaFell from Jefferson. Jefferson then eluded a sack and tossed underhand to Scott for a 12-yard gain that setup a 4-yard touchdown run by the bruising back.
LSU led 14-3 with 12:08 remaining in the half.
Then, Les Miles and the Tigers went to the bag of tricks, and made special teams plays that turned the game into a blowout.
An onside kick by Josh Jasper was recovered successfully by Stefoin Francois at the LSU 43. Though the Tigers went three-and-out, Georgia Tech's Andrew Smith fumbled punt when hit by LSU's Patrick Peterson. Ron Brooks recovered at the Yellow Jackets' 24. Six runs later — five by Scott — Scott scored for the third time, this time from the 1.
LSU led 21-3 with 8:27 to play in the half.
"We have some pretty nifty special teams guys," LSU coach Les Miles said. "We felt like we needed to maybe steal some possessions and keep the ball away from their offense."
Trailing and going nowhere offensively, Georgia Tech elected to fake a punt on fourth-and-8 at its 22. Yellow Jackets' defensive lineman Derrick Morgan took the snap from an up-back position but was cut down by Brooks after a 2-yard gain.
Two plays later, LSU overcame a holding penalty when Jefferson hit Dickson for a 25-yard touchdown and a 28-3 lead. Dickson's fifth touchdown of the season came with 5:21 left in the half.
Georgia Tech gained only four yards and punted back to the Tigers. With 3:12 to play, Jefferson and the Tigers took over at Georgia Tech 42-yard line after an 18-yard return by Trindon Holliday.
Williams scored four plays later on his second 17-yard run of the drive, giving LSU its largest bowl output in the first half in history.
Georgia Tech's drive into LSU territory was stalled when cornerback Chris Hawkins intercepted Nesbitt at the Tigers 8-yard line.
The Tigers led 35-3 at the half.
LSU had two opportunities to pad its lead in the third quarter, but only managed three points.
After Tech was unable to convert on fourth-and-5 from the LSU 46, the Tigers drove to the Georgia Tech 2-yard line but were stopped on three attempts.
Later, LSU started at the Georgia Tech 22-yard line but was penalized for a chop block. Colt David hit a career-long and bowl-record 53-yard field goal for the first points of the second half.
LSU led 38-3 with 1:56 to play in the third quarter.
Early in the fourth quarter, an 86-yard touchdown from Jefferson to LaFell called back after offsetting penalties.
Midway through the quarter, LSU punter Brady Dalfrey converted a fake punt with a 21-yard pass to safety Chad Jones. However, LSU only moved backward and punted.
LSU vs. Georgia Tech
2008 Chick-fil-A Bowl
Dec. 31, 2008 ? Georgia Dome (Atlanta, Ga.)
Postgame Notes
Team Notes
1. LSU's game captains were 6 Colt David, 93 Tyson Jackson, 79 Herman Johnson and 45 Quinn Johnson
2. Georgia Tech won the toss and deferred to the second half. LSU received the opening kickoff.
3. Tigers extending their notable consecutive starts streak tonight were: LT Ciron Black (40), DE Tyson Jackson (40), LG Herman Johnson (36) and C Brett Helms (29).
4. LSU recorded the 700th win in program history today in its 115th year of playing football. The Tigers became the 12th school to earn 700 wins in NCAA Division I-A history.
5. LSU has now won at least eight games in nine straight seasons with its victory in the 2008 Chick-fil-A Bowl.
6. The Tigers are now 7-1 all-time in games held at the Georgia Dome. LSU is a perfect 4-0 in Chick-fil-A Bowls and 3-1 in SEC Championship Games held at the site.
7. LSU improved its all-time bowl record to 21-18-1 in 40 appearances. The Tigers are also a perfect 4-0 in bowl games under head coach Les Miles.
8. The Tigers also picked up their 17th victory against a ranked opponent in four seasons under Miles.
9. With Charles Scott's 2-yard TD run with 11:58 to play in the first quarter, it marked the first time LSU had scored a touchdown on its first possession since Nov. 1 against Tulane.
10. LSU has scored at least 21 points in 33 of its last 34 games. LSU's streak of 31 straight games with at least 21 points was snapped against Ole Miss on Nov. 22. The last time before that the Tigers did not score at least 21 points in a game was at Florida on Oct. 7, 2006.
11. By scoring 35 points in the first half, LSU set a school record for points in a half in a bowl game, eclipsing the 34 points scored in the first half of the 2002 Sugar Bowl against Illinois.
12. By scoring 28 points in the second quarter, LSU tied a Chick-fil-A Bowl record for points in a quarter. That number is also a school record for points in a quarter in a bowl game.
13. LSU has outscored its opponents by a score of 157-44 in four bowl appearances under Les Miles.
14. LSU has now outscored its opponents 103-6 in the last 10 quarters at the Chick-fil-A Bowl.
15. LSU has now played 10 quarters at the Chick-fil-A Bowl without allowing an opponent to score a touchdown.
Individual Notes
16. RB Charles Scott tied a Chick-fil-A Bowl record for rushing TDs in a game with three in the first half. His effort ties the mark last achieved by Trent Green of Indiana in 1990. Three rushing TDs in a game is also a career high.
a. Scott now has 18 rushing TDs this season and a total of 28 rushing TDs for his career.
b. Scott is now No. 2 on LSU's all-time list for rushing TDs in a single season with 18, trailing only the 19 rushing TDs set by LaBrandon Toefield in 2001.
c. Scott is now in sole possession of sixth place on the school's all-time list for career rushing TDs after entering the game ranked No. 9 in school history. He passed Gary James (27), Harvey Williams (27) and LaBrandon Toefield (26) on the all-time list with his three rushing touchdowns on the night.
d. By rushing for three TDs in the first half, Scott became the first LSU player to rush for three TDs in one half since Domanick Davis accomplished the feat in the first half of the 2002 Sugar Bowl against Illinois.
17. PK Colt David connected on a career long 53-yard field goal with 1:56 remaining in the third quarter, marking the fourth time in his career that he converted on a field goal attempt of 50 yards or more.
a. David has now made 16 field goals this season and 54 field goals in his LSU career.
b. David scored a total of eight points in the 2008 Chick-fil-A Bowl to move into sole possession of No. 3 on the SEC's all-time scoring list with 369 points for his career, surpassing the 368 points scored by Florida's Jeff Chandler from 1997-2001.
18. QB Jordan Jefferson became the first true freshman to start a bowl game at QB for LSU since Herb Tyler did so at the 1995 Independence Bowl in Shreveport, La.
a. Jefferson completed his first nine passes of the game.
b. Jefferson's TD pass to Richard Dickson in the second quarter was his fourth of the season.
c. Jefferson set career highs in attempts (25) and completions (16).
d. Jefferson was named the games Offensive MVP.
19. WR Brandon LaFell has now caught a pass in 28 straight games dating back to the 2007 Sugar Bowl versus Notre Dame.
a. By making two catches in the game, LaFell finished the season with 63 receptions to rank No. 8 all-time for a single season at LSU.
b. He also finished the season with 929 yards receiving to rank No. 10 all-time for a single season.
20. With his TD reception in the second quarter, TE Richard Dickson tied former Tiger Brad Boyd (1972-74) for the LSU career record for TD receptions by a tight end with 10. It also marked his fifth TD reception this season.
21. WR Demetrius Byrd has now caught a pass in 23 straight games dating back to last year's Tulane game on Sept. 29, 2007.
22. CB Chris Hawkins picked off a Josh Nesbitt pass in the final minute of the second quarter for the third interception of his career and first since intercepting two passes in LSU's 26-21 win over Auburn back on Sept. 20.
23. P Brady Dalfrey completed a 21-yard pass to S Chad Jones on fourth-and-5 late in the fourth quarter, marking Dalfrey's first career pass completion and Jones' first career reception.
"I really enjoy this team. This football team has achieved through struggles throughout the year."
On Jordon Jefferson:
"There were several times in this season that were different for Jordon. When we lost a quarterback…he really responded. The best thing is he's a cool customer."
(talking about quarterback) "He played like a veteran. He's young, but he didn't play like it. I think we found ourselves a quarterback."
Tyson Jackson
"Football is football. The coaches said ?Don't stop, just keep doing what you're doing.'"
"At first we just concentrated on stopping the dive. Once we did that we just took it from
"It's a wonderful feeling to knock off a good team like GA Tech. Now we're just looking forward to next year."
LSU Quarterback – Jefferson
"Georgia Tech is a really good team so as an offense we knew we were going to have to execute and put some points up on the board."
Jefferson continued…
"I felt more prepared to execute the offense. I'm proud of my performance and the team's performance as well."
(asked about 2nd start as quarterback) "I respect Coach Miles and the coordinators and their decisions. When my opportunity came I had to do what I could do."
"It felt good that the players and coaches felt confident in me and that the team played well enough to win the way we did."
"It was very exciting. My adrenaline was pumping. I just wanted to put points up on the board."
LSU Richard Dickson
(about Jefferson) "I thought he played well in our last game against Arkansas too. I'm so proud of Jordan and the way he stepped up."
"We know we can do it. We can beat anybody, we just had to come out and put it all together."
"Things didn't go the way we wanted this year and people didn't respect us. We wanted to come back and earn their respect."
Charles Scott, LSU
"We just came out and played LSU football and did what we had to do to get the win."
(on defense) "They just pinned their ears back and went after them. We've practiced really hard on defending the option and they did a great job out there and put the offense in a great position whenever we got the ball."
Kirston Pittman #49, LSU
"The coaches had a great game plan. We knew it was going to start up front with the defensive line. Everyone went out and did their job and we got it done."
"That's team ball. The offense executed and did their job and we executed and did what we needed to do to put them in position to score. When you play good defense you have a chance to put your offense in a good position."
Jordon Jefferson, #9, LSU
(on starting the game 11-12) "It's the role of the QB to be cool in the pocket. I trust my line to give them the time. And I trust my receivers to catch the ball
"From day one I had to become a leader in order to be on the field. Even though the guys are a lot older than me I had to find a way to become a leader.


text:
Our Verdict
I occasionally take a second look at products that have been substantially updated since their original Mac Gems reviews—especially if those products are among our favorite Gems, and especially if the changes warrant a new rating. Today I'm taking just such a look at two recent Gems, Fantastical ($20; Mac App Store link) and Moom ($5; Mac App Store link).
Fantastical 1.1
I originally reviewed Fantastical 1.0 back in May, praising it as "a great package that handles—with an attractive interface and some impressive options—most of the things you use your 'big' calendar program to do." If you've never used Fantastical, its icon lives in your menu bar, displaying the day's date. Click the icon, and a beautiful calendar drops down, showing the current month, with upcoming events listed below; you choose which calendars' events appear, as well as the number of events or days' worth of events. Click an event to view its details, or click a date to see its events; a search field lets you quickly find events.
It's also easy to create new events from within Fantastical. You can double-click a date and then fill in the event's details, but Fantastical's standout feature is its natural-language event creation. You just type (in English) a conversational description of the event; Fantastical parses your text to fill in the details accordingly. Press Return, and the new event is created, letting you get right back to work. (For example, if I type
Macworld Staff Meeting Friday 10a Rm500 /work, Fantastical creates a new event, Macworld Staff Meeting, in my Work calendar with the upcoming Friday as the date, room 500 as the location, and 10 a.m. to 11 a.m. as the time.) Include the name of an Address Book contact, and Fantastical can add that person to the event's invite list. Lion's version of iCal offers similar functionality, but Fantastical simply works much better, and Fantastical works with any calendar you've set up in Apple's iCal, BusyMac's BusyCal, or Microsoft's Entourage or Outlook, as well as with MobileMe, iCloud, Google Calendar, and Yahoo Calendar accounts.
What's new: Since version 1.0, the developer of Fantastical, Flexibits, has updated the program four times, and those updates have brought a number of new and useful features, as well as the usual minor improvements and bug fixes. The most significant new features are the capability to edit and delete events—actions that previously required you to open your preferred calendar program—and the capability to add and edit notes for events.
My other favorite new feature is the Fantastical menu extra ( 22kb download link). Run this tiny program, and you can reposition the Fantastical menu anywhere in the menu-extras area of your menu bar. (I prefer it near the right edge of the screen, next to Apple's clock menu.) Other new features let you add multiple alarms automatically; use "launcher" apps such as LaunchBar and Alfred to send data directly to Fantastical; and use several Lion trackpad gestures and additional keyboard shortcuts to navigate events and calendars.
In my original review, I wrote that Fantastical doesn't include every feature you might want. Fantastical 1.1 has closed that gap considerably, to the point where many people could get by without ever opening iCal.
Moom 2.3.1
When I first reviewed Moom 1.1 back in April, it had already become one of my favorite Mac utilities by making it easier to resize, move, and manage windows in OS X. With Moom installed, if you move the mouse cursor over the green "zoom" button in the upper-left corner of any window, a palette appears containing a small row of iconic buttons, with each button illustrating a common window size and position: full screen or filling exactly half of the screen on the left, right, top, or bottom. Click one of these buttons, and, like magic, the window is moved and resized appropriately. (Click-drag one of these half-screen buttons, and you can reposition the window to fill a quarter of the screen or, if you have multiple displays, to move it to a different display.)
If you prefer using the keyboard, pressing a keyboard shortcut brings up Moom's keyboard-control overlay (bezel), which lets you use the arrow keys to move and resize the current window; modifier keys let you determine how much to move or resize with each key press. You can also use Return, Space, and Tab to zoom the current window to fill the screen; move the window to the center of its current display; or revert the window to its original size and location. (You choose, in Moom's settings, which of these keys performs each action.)
What's new: Moom has been updated eight times since my original review, adding dozens of improvements and new features. For those who favor mouse-pointer control, my favorite new feature displays, just below the zoom-button presets, a grid representing the current display and the window's current position on it. Simply draw a rectangle anywhere on that grid, and the window is resized and repositioned accordingly. (As you're drawing, a useful window-preview outline appears on your screen to show you exactly where, and how big, the resulting window will be.) It's a quick-and-easy way to precisely move and reposition windows, and you can choose, in Moom's settings, the number of rows and columns in the grid—in other words, how precisely you can resize. You can also access and use this grid with keyboard commands.
But you aren't limited to Moom's presets or manually drawing window positions on a grid, as Moom's new Custom settings screen now lets you configure custom presets and actions. The available options include various combinations of moving and resizing windows to custom sizes and positions, moving and resizing windows by specific increments, and moving windows between displays. Your custom actions appear in a new menu within Moom's zoom-button palette.
You can also assign a keyboard shortcut—single-key or multi-key—to each custom action. Multi-key shortcuts work at any time, without requiring you to bring up Moom's keyboard-control overlay. To access an action using a single-key shortcut, you first bring up that overlay, then press the one-key shortcut. (As an example, I've assigned B to a preset that represents my favorite window size and position for BBEdit.) To help you remember your shortcuts, whenever you bring up the keyboard-control overlay, you can now see a "cheat sheet" that displays all available actions and shortcuts.
The other big new feature is multi-window-layout snapshots. If you've got a favorite setup, with each program's windows meticulously organized, you can take a snapshot of that layout and then use Moom to restore it at any time. This feature can be helpful for restoring order, but it's also quite useful if, for example, you've got a Mac laptop and you regularly switch between using one display (just the laptop's) and multiple displays (the laptop's and an external display while at the office). You can manually trigger the appropriate snapshot, but even easier is Moom's setting to automatically restore a snapshot whenever you switch to a particular number of displays (or whenever your display matches a particular resolution—useful if you switch between different single displays).
Moom's developer, Many Tricks, has also added a number of minor-but-useful options and tweaks; and Moom now works with more programs, better supports multi-display configurations, and includes some basic AppleScript support. And both mouse and keyboard control now work with Quick Look windows.
There are many window-management apps out there—I've seen literally dozens debut in the past year alone. I've tried most of them, and Moom remains my favorite by being simple enough for new users, while offering plenty of features and flexibility for those who crave more options. It's also one of the few that can satisfy both keyboard junkies and those who prefer to use a mouse, trackpad, or trackball.
(Disclosure: Former Macworld editor Rob Griffiths is now an employee of Many Tricks, the developer of Moom.)
Want to stay up to date with the latest Gems? Sign up for the Mac Gems newsletter for a weekly email summary of Gems reviews sent directly to your Inbox. You can also follow Mac Gems on Twitter.


text:
Just click the Like Button below
To get your5%OFFCoupon Code
Show me my Coupon!
Join us to get social with us!
This unique decorative accent pillow is crafted from 100-percent natural cotton and linen fabric. This fashion forward pillow has eclectic bohemian style. The contrasting intricate pattern and multi-color accents create a unique addition to spaces. The pattern is on the front only. The back is solid color.
Green Decorative Zig Zag Arrow Boho Throw Pillow Case Cover 16X16


text:
The New Demography of America's Schools
This report examines how immigration is changing the demographic profile of the United States' elementary and secondary student population, framing the analysis within the context of the nationwide implementation of No Child Left Behind (NCLB). Authors discuss the characteristics of children of immigrants and limited English proficient (LEP) children; explore the ties between family income, parental education, linguistic proficiency and isolation; and disaggregate children of immigrants by race, ethnicity, and country of origin.
The report finds that sustained high levels of immigration since the 1970s have led to a rapid increase in the number and share of children of immigrants among the school-age population. By 2000, children with immigrant parents represented one in five of all children under age 18. While findings indicate that the vast majority of children of immigrants are U.S.–born citizens, approximately 5 percent of these children appear to have undocumented parents. The LEP share of students also experienced rapid growth. Authors believe that the high share of LEP children in linguistically isolated households and the alarming fact that over half of LEP students are second- or third-generation children may pose significant obstacles as schools seek to meet NCLB accountability requirements for academic achievement and parental involvement.
Findings also indicate that half of school-age children of immigrants and two-thirds of LEP children come from low-income families; and that one-third of children of immigrants and half of LEP students have parents with less than a high school diploma. In addition, the report shows that rates of limited English proficiency and linguistic isolation are highest among Hispanic and Asian children of immigrants. Poverty rates appear to be higher for Hispanic and black children of immigrants, while Hispanic children are by far the most likely to have parents without high school degrees.


text:
Search This Blog
Sunday, December 4, 2011
In My Mailbox (16)
17 comments:
Unicorns! That is SUCH a cute sweatshirt! I also really love the cover of Take Me There. Hope you enjoy your books :)ReplyDelete
Aw, dude, thanks for the shout-out! YOU'RE the one that's awesome! I'm glad you like the sweatshirt, it's totally you. =DReplyDelete
Great haul this week! There are several books here that I haven't heard of that sound super rad, I'll have to add them to my wishlist.
- AnonymousDecember 4, 2011 at 9:21 AM
I enjoyed Ex-mas too! I have Take Me There and Across the Universe on my shelf; I still need to read them. Awesome IMM! Enjoy your books!ReplyDelete
New Girl looks great, it is supposed to be a retelling of Rebecca by Daphne DuMarier which is one of my favorite books.ReplyDelete
Check out my IMM here.
Emma @ Lost in a YA Book
That sweatshirt is too cute! Unicorns for the win!ReplyDelete
All of your books this week sound awesome. I'm especially jealous of Super Girl. That cover alone is awesome. Enjoy them all!
My IMM
Kristan @ Lost Amongst the Shelves
- AnonymousDecember 4, 2011 at 10:40 AM
Great books...we got several of the same ones. :)ReplyDelete
I LOVE the hoodie. Love unicorns!
Amanda @ Letters Inside Out - My IMM
I really want Life is But a Dream! I got New Girl this week also, and am super excited to start it!ReplyDelete
Here's my IMM
That sweatshirt is so cute! Awesome books this week too, love ATU :)ReplyDelete
Happy reading!
Great books! I can't wait to read New Girl. I hope that you enjoy your new books!ReplyDelete
Ladybug Storytime
That is an awesome sweatshirt! And awesome books this week! I've never heard of Ex-mas but I want to check it out. Especially if you liked it!ReplyDelete
Take Me There sounds really good, i hope you enjoy it! Come check out my IMM!ReplyDelete
Oh my gosh, I LOOOOVE the cover for Sugargirl Mixtapes -- it's so creative! Plus, I adored Across the Universe and I can't wait for A Million Suns to release either! And that unicorn sweatshirt is just SO CUTE!! :)ReplyDelete
Awesome mailbox this week, Sarah! I hope you enjoy all of your books!
OHhh Halflings looks good!! I'm thinking about requesting it from NG too! Enjoy!ReplyDelete
Anna @ Literary Exploration
I'm REALLY excited to read New Girl! And Across The Universe! Yay! This was one of my fave books of this year.ReplyDelete
LOVE the unicorn hoodie! lol It's adorable! I love Greek too! One of my fave shows! I also downloaded Supergirl Mixtapes this wk. It looked way too cute not too!ReplyDelete
Ooh endless summer is pretty cute! And totally love the covers of life is but a dream and super girl mixtapes!!ReplyDelete
Great IMM this week!!
- juhina
OMG. I love Greek!! I was so sad when it ended, but I really enjoyed it. Happy watching :]ReplyDelete


text:
The Bladewood Grove
Special Containment Procedures
SCP-143 is to be contained in the valley adjacent to Bio-Research Area-12, an area over 2 km². Area surrounding SCP-143 for up to 20 km, and all lines of sight from the surrounding hilltops, are to be denied public access. SCP-143 is to be watered twice every day on a regular basis via a large sprinkler system, unless already watered by local precipitation. Personnel are not allowed to enter the enclosure without Level 4 administrative clearance, and are advised not to touch any of SCP-143, nor stand beneath them unless wearing proper protective gear. It is important that no one be within the containment area when SCP-143 begins to shed, however after the shedding has concluded, the collection of the fallen petals for testing purposes has been authorized by the project director (see SCP-143 Testing Log).
SCP-143 is a plantation of 300 specimens of a unique type of tree. The trees are similar in appearance to Prunus x yedoensis (Japanese Sakura), or cherry blossoms. They bear no fruit, and the only known way of reproduction is by careful "own root" propagation using cut saplings from an older sample.
The petals are a light pinkish color, slightly translucent, and with a texture of smooth glass. Care must be taken when handling the petals, as their edges are razor sharp, and can easily slice through flesh if mishandled.
The wood and bark are a light grayish color, with a texture expected of wood, although the grain is very smooth to the touch.
However, the petals and wood of these trees are much harder than most natural or man-made substances, reaching up to 5,000 HB on the Brinell scale, and withstanding temperatures of up to 1800°C. The weight-to-strength ratio surpasses even that of titanium, being some fifteen percent (15%) lighter than aluminum. Despite this hardness, the wood and petals are quite supple and are as pliable as most woods are.
Both are notoriously difficult to work due to their properties, but under high temperatures, upwards of 1500°C, separate pieces are capable of being fused together. They make excellent armor, shielding, and weapons. Due to the slow growth of the plants, the material is slow to harvest, although the petals are shed regularly enough, falling from the trees twice every year.
Addendum 143-1 The trees were grown on-site from saplings obtained from parent plants located in Nara Prefecture, Japan, in 1905. The parent trees were owned by a family of traditionalist swordsmiths, claiming to be descended from a legendary sword maker named Amakuni. They referred to the original trees as "jinki no kodachi" (刃木の木立), or the "Bladewood Grove." It is from them that the Foundation gained the techniques to cut and work the wood and petals into serviceable items.
The original trees are still in Japan, owned by the government, and still tended to by the same family. However, the government has denied all existence of the trees, and any products made from them are kept within the country.
Document 143-A We lost three staff to 143 today. They were collecting petals dropped by the trees the previous day, when a sudden gust picked up, shaking a good deal of the petals from the trees and blowing them around. Stayed that windy for the whole day. I'd send a cleanup crew, but it's still pretty windy and the odd petal is still falling. We'll have to pick up the remains when the wind dies down in a couple days.


text:
Learn to surf in Cape Town, South Africa!
Gary's Surf School is an established company specializing in professional surfing tuition and coaching. The school has been in existence since 1989, making it the oldest surf school in the country. The Surf School is well known by locals and is internationally renowned, with many tourists returning year after year to continue developing their surfing skills.
Gary's Surf School is located on Beach Road in sunny Muizenberg, Cape Town. Muizenberg Beach is known for its gentle sloping white beach and consistent waves making it conducive to learning the art of surfing quickly and safely.
Gary himself is personally involved in some of the lessons and many young up and coming surfers are products of the school. With a solid reputation built on trust, service and results, we have become one of the most popular surf schools in South Africa!
There a no reviews, click 'Add a review' to submit one
Have you booked with Gary's Surf School? Please share your experience and submit your review.


text:
Your spark plugs can give you a lot of information as to how well your engine is running, and predict problems that are occurring long before you identify any other symptoms. Make it a habit of looking closely at your spark plugs every time you remove or change them. Here's what you can be looking for:
Brown to grayish-tan color and slight electrode wear. Correct heat range for engine and operating conditions.
Symptoms: Rounded electrodes with small amount of deposits on the firing end. Normal color. Causes hard starting in damp or cold weather and poor fuel economy. Plugs have been left in the engine too long. Replace with new plugs of the same heat range.
Carbon Deposits
Symptoms: Dry, sooty deposits indicating a rich mixture or weak ignition. Causes misfiring, hard starting and hesitation. Make sure the plug has the correct heat range. Check for a clogged air filter or problem in the fuel system. Also check for ignition system problems.
Ash Deposits
Symptoms: Light brown deposits encrusted on the side or center electrodes or both. Derived from oil and/or fuel additives. Excessive amounts may mask the spark, causing misfiring and hesitation during acceleration. If excessive deposits accumulate over a short time or low mileage, install new valve guide seals to prevent seepage of oil into the combustion chambers. Also try changing gasoline brands.
Oil Deposits
Symptoms: Oily coating caused by poor oil control. Oil is leaking past worn valve guides or piston rings into the combustion chamber. Causes hard starting, misfiring and hesitation. Blue smoke will be seen coming from exhaust. Correct the mechanical problem causing the condition and install new plugs.
Gap Bridging
Symptoms: Combustion deposits lodge between the electrodes. Heavy deposits accumulate and bridge the electrode gap. The plug ceases to fire, resulting in a dead cylinder. Remove the deposits from between the electrodes.
Too Hot
Symptoms: Blistered, white insulator, eroded electrode and absence of deposits. Results in shortened plug life. Check for the correct plug heat range, over-advanced ignition timing, lean fuel mixture, intake manifold vacuum leaks, sticking valves and insufficient engine cooling.
Symptoms: Melted electrodes. Insulators are white, but may be dirty due to misfiring or flying debris in the combustion chamber. Can lead to engine damage. Check for the correct plug heat range, over-advanced ignition timing, lean fuel mixture, insufficient engine cooling and lack of lubrication.
High Speed Glazing
Symptoms: Insulator has yellowish, glazed appearance. Indicates that combustion chamber temperatures have risen suddenly during hard acceleration. Normal deposits melt to form a conductive coating. Causes misfiring at high speeds. Install new plugs. Consider using a colder plug if driving habits warrant.
Symptoms: Insulators may be cracked or chipped. Improper gap setting techniques can also result in a fractured insulator tip. Can lead to piston damage. Make sure the fuel octane is high enough. Use care when setting the gaps on new plugs. Avoid lugging the engine.
Mechanical Damage
Symptoms: May be caused by a foreign object in the combustion chamber or the piston striking an plug that is too long. Causes a dead cylinder and could result in piston damage. Repair the damage and correct the cause.
Coolant Leak/Head Gasket
Symptoms: Coolant is entering the cylinder, either through a leaking/failed head gasket, or a cracked block. The coolant "steam cleans" the plug, so the plug appears clean and shiny.
Incorrect carburetor mixture can also be seen on spark plugs:
Some more examples:
How to "read" used spark plugs
Information and questions on GL1800 Goldwings (2001-2017)
Post Reply
2 posts • Page 1 of 1
- twostrokes48
- Posts: 577
- Joined: Mon Feb 14, 2011 11:21 pm
- Location: San Antonio,TX
- Motorcycle: 98 Goldwing 1500 trike
75 GL1000 (restoring)
98 Goldwing with landing gear (for sale)
94 Goldwing 1500- towpac trike (sold)
88 Goldwing 1500- (sold)
84 GL1200 Aspy-SOLD
75 GL1000(stolen 87)
88 GW trike (totaled)
1972 750k2
Re: How to "read" used spark plugs
great chart to have handy, maybe move it somewhere easy to find, maybe nu a dyi tuneup or something...just a thought.
Post Reply
2 posts • Page 1 of 1


text:
Welcome to Oakwood Heights of Oil City, PA.
A retirement community committed to making aging easier.
This stage of life can be the best! Especially when you have a place that feels like home. Where you can enjoy time with family and friends without the worries of home maintenance, housekeeping or laundry. Where there's delicious dining along with convenient services and amenities to make every day a little easier. That's what's special about Oakwood Heights, where we're dedicated to making aging easier, more comfortable, more manageable in every way.
Where you'll find a complete range of senior living options, including independent living and skilled nursing as well as short-term rehabilitation. And where you'll have peace of mind knowing that compassionate care is close at hand, whenever needed.
Here's a place that invites you to truly make yourself at home.
Welcome to our community…Welcome to Oakwood Heights!
To learn more about our our services, please contact us online or call us at 814-676-8686.


text:
71 upcoming shows @ 24 different spots
49 upcoming shows with flyers
24 ALL AGES shows!
If you would like to comment on this page, please leave a comment in the box in the main content area and it will appear
in the shoutbox complete with linkage.
Simply hover over any band you're interested in and we'll pull up a bio and some links for you. Hide this


text:
Check back regularly here for Land Surveyor and home improvement tips and tricks to make sure you get the most out of your next Land Surveyor!
Customer happiness is the chief ambition
Our goal is always to guarantee that you will be entirely delighted whenever you hire our company for top level Land Surveyor in Vermont. Our company offers knowledgeable guidance and remarkable service to each of our clients. We can resolve all your questions and concerns. Your own Land Surveyor venture is our specialty, and we are going to ensure that you are completely satisfied. We can arrive at the planned time, not late, and take care of the project with your exact specifications in the period of time that we quote in the beginning. You will not encounter more unforeseen expenditures, because we know what we're working at, so we provide you with a precise quote before starting off work on your home or business. You can easily rely on us to finish the job right the first time and to save a little money . Get a complimentary quote by contacting our team right now, and we're going to answer all your important questions.


text: Suppose that $G$ is a group acting on a fibre bundle $(F,E,B)$ by bundle automorphisms. In this case, the action automorphisms $E\to E$ give the integral homology $H_\ast(E;\mathbb{Z})$ the structure of a $G$-module. Also, the action automorphisms $F\to F$ and $B\to B$ give each module $H_p(B;H_q(F;\mathbb{Z}))$ the structure of a $G$-module. Can the Serre spectral sequence of the fibre bundle be made $G$-equivariant in the sense of being a spectral sequence of $G$-modules converging to $H_\ast(E;\mathbb{Z})$, and with second page $E_{p,q}=H_p(B;H_q(F))$ (considered as $G$-modules in the above sense)?


text:
This guide is targeted at Microsoft Dynamics AX
installation specialists who will deliver the AX server
environment where Sana Commerce will be installed.
It provides information about hardware, software and network
requirements for the AX server and the step by step
installation guide for Microsoft Dynamics AX and services.
A typical Sana Commerce installation consists of three
This document will focus on the AX server:
Ensure that the AX server you are delivering meet the
hardware, software and network requirements.
Help wizard will guide you step by step through
the Microsoft Dynamics AX environment preparation and
installation of Microsoft Dynamics AX and services.


text:
What's in my Garage? 1998 Honda Magna (v-4 rocket bagger), 1982 Honda CM450 (flamed out econocommuter), 1976 Honda GL1000 (RatRod)
The best of the best. These folks have ridden and shared more roads than any other ORJ member this month.
Road Trips & Trip Planner:
Bike Routes, Roads, and Maps:


text:
I've just checked in the media data cache to Gecko trunk. It should appear in nightly builds tonight and on the 1.9.1 branch soon-ish. If you just can't wait to try it, there are try-server builds for Linux, Mac and Windows.
Media applications want fast, "on demand" random access to media data, for pausing, seeking, etc --- something like the standard "seek/read" OS file APIs. But we are primarily interested in transporting media data using HTTP over the Internet, which has high latency to open a connection, requires a new connection for every seek, may not even support seeking on some connections (especially live streams), and uses a push model --- data comes from the server and you don't have much control over the rate. Also, transferring data over the Internet can be slow and/or unpredictable, so we want to read ahead to buffer and cache as much data as possible.
The job of the media cache is to resolve this impedance mismatch. The media cache reads data from Necko channels into file-backed storage, and offers a random-access file-like API to the stream data (nsMediaCacheStream). Along the way it solves several problems:
- The cache intelligently reads ahead to prefetch data that may be needed in the future.
- The size of the cache is bounded so that we don't fill up storage with read-ahead data.
- The cache stores played data as well as read-ahead data so that backward seeks and replay can be served without redownload.
- Cache replacement is managed globally so that the most valuable data (across all streams) is retained.
- The cache can suspend Necko channels temporarily when their data is not wanted (yet).
- The cache translates file-like seek requests to HTTP seeks, including optimizations like not triggering a new seek if it would be faster to just keep reading until we reach the seek point, and adjusting the seek destination to avoid re-downloading data already in the cache. The "seek to EOF" idiom to determine file size is also handled efficiently (seeking to EOF and then seeking back to the previous offset does not trigger any Necko activity).
- The cache also handles the case where the server does not support seeking.
- Necko can only send data to the main thread, but nsMediaCacheStream can distribute data to any thread.
- The cache exposes APIs so clients can detect what data is currently cached.
(Our previous strategy was incredibly naive: just read all the incoming data from the HTTP stream and store it in memory, and throw it away after it has been played once; seeks throw away all data and create a new HTTP stream.)
Although HTTP is the most important transport and we only support transport-level seeking via HTTP byte-ranges, the media cache works with any kind of Necko channels and provides random access to cached data even for, e.g., FTP streams.
The media cache is not persistent. It does not currently allow data from one load to be used by other loads, either within the same browser session or across browser sessions.
The media cache is block-based. Streams are divided into blocks of a fixed size (currently 4K) and we cache blocks. A single cache contains blocks for all streams. The cache size is controlled by the media.cache_size preference (which is in KB). The default size is 50MB.
The replacement policy predicts a "time of next use" for each block in the cache. When we need to free a block, the block with the latest "time of next use" will be evicted. Blocks are divided into different classes, each class having its own predictor:
- FREE_BLOCK: these blocks are effectively infinitely far in the future; a free block will always be chosen for replacement before other classes of blocks.
- METADATA_BLOCK: these are blocks that contain data that has been read by the decoder in "metadata mode", e.g. while the decoder is searching the stream during a seek operation. These blocks are managed with an LRU policy; the "time of next use" is predicted to be as far in the future as the last use was in the past.
- PLAYED_BLOCK: these are blocks that have not been read in "metadata mode", and contain data behind the current decoder read point. (They may not actually have been read by the decoder, if the decoder seeked forward.) These blocks are managed with an LRU policy except that we add REPLAY_DELAY seconds of penalty to their predicted "time of next use", to reflect the uncertainty about whether replay will actually happen or not.
- READAHEAD_BLOCK: these are blocks that have not been read in "metadata mode" and that are entirely ahead of the current decoder read point. (They may actually have been read by the decoder in the past if the decoder has since seeked backward.) We predict the time of next use for these blocks by assuming steady playback and dividing the number of bytes between the block and the current decoder read point by the decoder's estimate of its playback rate in bytes per second. This ensures that the blocks farthest ahead are considered least valuable.
For efficient prediction of the "latest time of next use", we maintain linked lists of blocks in each class, ordering blocks by time of next use. READAHEAD_BLOCKS have one linked list per stream, since their time of next use depends on stream parameters, but the other lists are global.
"Time of next use" estimates are also used for flow control. When reading ahead we can predict the time of next use for the data that will be read. If the predicted time of next use is later then the prediction for all currently cached blocks, and the cache is full, then we should suspend reading from the Necko channel.
Unfortunately suspending the Necko channel can't immediately stop the flow of data from the server. First our desire to suspend has to be transmitted to the server (in practice, Necko stops reading from the socket, which causes the kernel to shrink its advertised TCP receive window size to zero). Then the server can stop sending the data, but we will receive data roughly corresponding to the product of the link bandwidth multiplied by the round-trip latency. We deal with this by letting the cache overflow temporarily and then trimming it back by moving overflowing blocks back into the body of the cache, replacing less valuable blocks as they become available. We try to avoid simply discarding overflowing readahead data.
All changes to the actual contents of the cache happen on the main thread, since that's where Necko's notifications happen.
The media cache maintains at most one Necko channel for each stream. (In the future it might be advantageous to relax this, e.g. so that a seek to near the end of the file can happen without disturbing the loading of data from the beginning of the file.) The Necko channel is managed through nsMediaChannelStream; nsMediaCache does not depend on Necko directly.
Every time something changes that might affect whether we want to read from a Necko channel, or whether we want to seek on the Necko channel --- such as data arriving or data being consumed by the decoder --- we asynchronously trigger nsMediaCache::Update on the main thread. That method implements most cache policy. It evaluates for each stream whether we want to suspend or resume the stream and what offset we should seek to, if any. It is also responsible for trimming back the cache size to its desired limit by moving overflowing blocks into the main part of the cache. The policy mechanism is fairly simple and stateless; it examines the current state of the cache and of all consumers, and decides what each stream should do at this moment (i.e., should the stream be trying to read data and if so, at what offset should it be trying to read).
Streams can be opened in non-seekable mode. In non-seekable mode, the cache will only call nsMediaChannelStream::CacheClientSeek with a 0 offset. The cache tries hard not to discard readahead data for non-seekable streams, since that could trigger a potentially disastrous re-read of the entire stream. It's up to cache clients to try to avoid requesting seeks on such streams.
The media cache is primarily designed to support HTML5 media elements, but potentially it could be useful in other places where we want a mix of random and sequential access to large files accessed over HTTP.


text:
"If you don't stand
for something, you will fall for something."
(African proverb)
What would you do if you had to face down an angry and violent
What would you do if the only people you trusted were the handful
of friends next to you?
How far would you go to protect your family, your home, all the
things you'd worked hard for all your life?
Would you kill to protect your home and those you loved? Would you
die for what you believed was right?
What if you had a gun and a hundred rounds of ammunition? What if
the fear was stronger than reason?
These are the questions that Ossian Sweet must have asked himself
long before a hot September evening in 1924. As a child, he had
witnessed the cruel reality of racial hatred first hand. What would
he do if all that he was most important in the world to him was
threatened? How would he protect his life and the lives of those
he loved? Ossian Sweet, his wife, brothers and friends, chose to
take a stand that day, and with this one choice, the Detroit social
boundaries were changed forever.
In 1987, to preserve this important historical event and the trials
that followed it, Arthur Beer wrote his play "Malice Aforethought:
The Sweet Trials." As part of Black History Month and with
the support of the Michigan Association of Libraries and area law
asociations, the play will be presented in 2007.
The Detroit Metro Times voted Malice Aforethought: the Sweet Trials play the "Best chance to see Detroit history on stage." On the Metro Times Community Chest page on October 18, 2006, the web site tells readers:
This site made possible by a grant from the
Michigan Council for the Arts and Cultural Affairs.


text:
209: Display of disapproval
I guess you could guess the equivalent of a Tzimisce faceplant. But your own imagination would surpass my visual exploits ANY day. It's pure fucking H.R. Giger material that, and maybe some day I'll dwell into the transmutation horrors without the crutch and helping hand of humour to guide me. But not today!
I think I'm slowly losing my sanity. It's a fascinating experience where everything around me slowly deteriorate into a strange and foreign wasteland. Unaware and unaccustomed to the customs of the poor natives who reside within, I exist beside them rather than alongside them. Would that make me a juxtaposer? *Badum-dish* Oh ho ho ho!
I really don't GET the world right now.. or I get it too well.. I prefer the latter since it gives me that edge of superiority that elevates me from "outcast emo" to "visionary prophet". It's all really semantics, is it not?
Thanks so much to all you who post comments! It's fucking awesome to hear from you readers! I love you! =D
Ouch.. I mean, y'know.. Ouch!..
Torpor 2011-05-12
Let the dead rest until they are needed again. It is no use to deny it any longer. I have to put Vampires Suck on indefinite hold for now. There's a number of reasons why, and I'll try to sum them up fairly quickly.
One thing is the internet as a medium in itself. You've seen me contemplate in earlier commentaries how the need for proper updates and a fair amount of content each update makes longer storylines challenging. After my first creative breakdown, I started the Chronicles of coffee and cigarettes, adjusting focus from the setting to those who (ab)use it. These were short gags presented as strips. But I don't want to make strips. Or gags for that matter. At least not now.
VS evolved into something I find much more interesting creating — a story. Some of you, who play any edition of WoD, realise this as well. It's not about how shitty or badass your character is in a game mechanic balance perspective. It is the drama that inevitably will surface because everything you touch will turn to shit. Life's still a fucking joke, but everyone doesn't get it, and others don't find it particularly funny.
Continuing on what has been done is troublesome. I could start making proper 'zines altogether out of VS, but there's simply too much backstory only available online. And then there's my conscious decision to direct VS to those already familiar with the Masquerade-setting. A proper shift in medium would require a full re-boot, and probably to drop the universe by White Wolf altogether.
But I assure you that the vampires have not returned into the shadows forever. They are always present, and the great resource material for classical Victorian horror can be applied within a multitude of settings. But VS as it is and has been, will not be for quite a while. I am deeply indebted to you all for giving me these 4 years.
Thank you so much,
The intellectual property of the Old World of Darkness as well as


text:
The Internet of Things is nothing without batteries and plugs. But it's possible to build a sensor network that uses harvested energy that comes from changes in temperature, vibrations, wind and light, as Texas Instruments (TI) will demonstrate at the Consumer Electronics Show in January.
The idea of harvesting power has a long history and there are many applications of it today. However, big solar panels or large sensors that can capture energy from vibrations, heat and light are impractical in many Internet of Things sensor applications, which are tiny in size.
TI said it has developed electronics capable of taking small amounts of power generated by harvested sources and turning them into a useful power source. This means that the sensors used to collect the energy can be small as well.
All these ambient energy sources, such as the difference in temperature in a pipe carrying hot water and the outside air, can generate 300 to 400 millivolts, which isn't enough to power anything. TI has built an "ultra-low powered" DC-to-DC switching converter that can boost this power to 3 to 5 volts, which is sufficient to charge a battery, according to Niranjan Pathare, senior marketing development manager at TI.
To power wearables, the company has demonstrated drawing energy from the human body by using harvesters the size of wristwatch straps, Pathare said. It has worked with vibration collectors, for instance, about the same size as a key.
It's possible that a smartwatch could use two harvested power sources, light and heat, from the body. These sources may not gather enough power to keep a smartwatch continuously operating without action by the user to charge it, but it may give the user's device a lot more battery life.
"Obviously, the longer you can make that [battery] last the happier the consumer is going to be with its performance," said William Cooper, a TI product marketing engineer.
The technology has many applications in industrial and home environments. If a device or sensor isn't connected to a power network, it will need a battery. Vendors will say that these batteries have the potential of lasting for years since they are only transmitting small amounts of data. But, still, who wants to worry about a battery?
Of the work done by Texas Instruments, Steve Ohr, an analyst at Gartner, said, "they have the parts that will take this micro-power input and actually make some useful voltage and current that could power something."
Ohr said there's a lot of work that needs to be done before this technology finds its way to the market in uses such as powering a smartwatch, specifically in improving the sensors that collect energy.
"You really need a big surface area to generate a very small amount of electricity," Ohr said, and it will take more work on the materials used to make the sensors before they are ready for the wearable market, in particular.