text:
TLDR: The creation a C# expression tree is not cached, and using it to simulate a methodof keyword is terribly slow. This article is about reconsidering the use of this technique when performance is a concern.
During the development of my last projects, and it's been like that for a while, I've been used to look for ways to express programs in a more declarative or functional way.
LINQ is a pretty good tool to acheive that, as well as fluent interfaces, lamdbas and all those neat language features and tricks.
But there are some times when the language is not there to support patterns, like with the use of the IPropertyChanged interface. The language (and the CLR for that matter) does not publicly support intercepting calls to properties or methods. That can actually be done through Transparent Proxies or dynamic proxy generation, but these are not supported on Windows Phone 7. The latter somehow will on WP7.1.
Anyway, using that interface requires raising an event with a string containing the name of the property that has changed.
The use of metadata in the form of strings is unfortunately not refactoring friendly, and if you change your property name, you've got a bug on your hands.
Since there is no methodof keyword in C#, you could say that the language is against you since there is no direct way to get the name of a property or method at compile time.
This can still be done through reflection with plumbing code that uses Expression Trees to work around it, and it works pretty fine.
That way you can easily write nice wrappers like this one :
public int MyProperty { get { return GetValue(() => MyProperty); } set { SetValue(() => MyProperty, value); } }
That way, you get both the type safety and the refactoring friendly use of INotifyPropertyChanged.
If you crack open the assembly for a property like this one with a disassembler, you get this :
public int MyProperty { get { return this.GetValue<int>( Expression.Lambda<Func<int>>( Expression.Property( Expression.Constant(this, typeof(MainPage) ), (MethodInfo) methodof(MainPage.get_MyProperty) ), new ParameterExpression[0])); } set { this.SetValue<int>( Expression.Lambda<Func<int>>( Expression.Property( Expression.Constant(this, typeof(MainPage)), (MethodInfo) methodof(MainPage.get_MyProperty) ), new ParameterExpression[0]), value); } }
That's a lot of code !
And worse, that's not the end of it, because you'll have to traverse the expression just to get the "methodof", and then call the "Name" property to get the string. All this for a string that will never change after you've compiled your assembly.
But that would not be that bad if you executed that code once, or ran it on a desktop computer (or you don't care about performance). For desktop and server applications, where the cost of executing that kind of code is (almost) neglectible, you do not care much about that.
But if you execute that code a few million times, or run it on a Windows Phone 7 on the UI thread, you've got a problem. The expression is not cached, neither in a static variable or an instance variable, depending on the context. Sure, you could store it in an expression typed variable, and cache it manually that way, but you'd lose a bit declarativeness.
To make a small comparison, it takes 13 seconds on my Samsung Focus to execute 10,000 gets of the property using expressions, and takes 0.2 milliseconds to do the same using a simple string.
Pretty easy to choose, isn't it ?
That's where you lose the declarativeness away for performance, and cringe a little bit about it when you know that you'll have to chase a bug in the future because of a lazy rename. Still, you can have debug-time only code that walks up the stack and checks that the property actually exists, but you have to execute that code to find the bug.
Hopefully, there are tools like Postsharp that help in that regard, where a post processing step does the reflection once and for all, and injects that missing string. That's direction I'd rather not take, but since there's still no out of the box solution, that can be a good fit.
We're so used to techniques that avoid us to write boring code, but when performance is a concern, it is necessary to reconsider all coding reflexes and think twice before using them.
TLDR: The Reactive Extensions provide a TestScheduler class that abstracts time and allows for a precise control of a virtual time base. Using the Rx Schedulers mecanism instead of real timers enables the creation of fast running unit tests that validate time related algorithms without the inconvients of the actual time.
Granted, the title is a bit provocative, but nonetheless it's still a bad idea to use timer classes like System.Threading.Timer.
Why is that ? Because classes like this one are based on the actual time, and that makes it a problem because it is non-deterministic. This means that each time you want to test a piece of code that depends on time, you'll be having a somehow different result, and particularly if you're using very long delays, like a few hours, you probably will not want to wait that long to make sure your code works as expected.
What you want actually, to avoid the side effect of "real" time passing by, is virtual time.
The reactive extensions are pretty good at abstracting time, with the IScheduler interface and TestScheduler class.
Most operators in the Rx framework have an optional scheduler they can use, like the Dispatcher or the ThreadPool schedulers. These schedulers are used to change the context of execution of the OnNext, OnCompleted and OnError events.
But for the case of time, the point is to freeze the time and make it "advance" to the point in time we need, and most importantly when we need it.
Let's say that we have a view model with a command that performs a lengthy action on the network, and that we need that action to timeout after a few seconds.
Consider this service contract :
public interface IRemoteService { /// /// Gets the data from the server, /// returns an observable call to the server /// that will provide either no values, one /// value or an error. /// IObservable<string> GetData(string url); }
This implementation is exposing an observable based API, where the consumer of this contract must take into account the fact that getting data must be performed asynchronously, because it may not provide any value for a long time or even not return anything at all.
Next, a method of a view model that is using it :
public void GetServerDataCommand() { IsQueryRunning = true; ShowError = false; Service.GetData(_url) .Timeout(TimeSpan.FromSeconds(15)) .Finally(() => IsQueryRunning = false) .Subscribe( s => OnQueryCompleted(s), e => ShowError = true ); }
And we can test it using Moq like this :
var remoteService = new Mock<IRemoteService>(); // Returns far in the future remoteService.Setup(s => s.GetData(It.IsAny())) .Returns( Observable.Return("the result") .Delay(TimeSpan.FromDays(1)) ); var model = new ViewModel(remoteService.Object); // Call the fake server model.GetServerDataCommand(); Assert.IsTrue(model.IsQueryRunning); Assert.IsFalse(model.ShowError); // Sleep for a while, before the timeout occurs Thread.Sleep(TimeSpan.FromSeconds(5)); Assert.IsTrue(model.IsQueryRunning); Assert.IsFalse(model.ShowError); // Sleep beyond the timeout Thread.Sleep(TimeSpan.FromSeconds(11)); // Do we have an error ? Assert.IsFalse(model.IsQueryRunning); Assert.IsTrue(model.ShowError);
The problem with this test is that it depends on actual time, meaning that it takes at least 16 seconds to complete. This is not acceptable in a automated tests scenario, where you want your tests to run as fast as possible.
We can introduce the use of an injected IScheduler instance into the view model, like this :
.Timeout(TimeSpan.FromSeconds(15), _scheduler)
Meaning that the both Start and Timeout will get executed on the scheduler we provide, for which the time is controlled.
We can update the test like this :
var remoteService = new Mock<IRemoteService>(); var scheduler = new TestScheduler(); // Never returns remoteService.Setup(s => s.GetData(It.IsAny<string>())) .Returns( Observable.Return("the result", scheduler) .Delay(TimeSpan.FromDays(1), scheduler) ); var model = new ViewModel(remoteService.Object, scheduler); // Call the fake server model.OnGetServerData2(); Assert.IsTrue(model.IsQueryRunning); Assert.IsFalse(model.ShowError); // Go before the failure point scheduler.AdvanceTo(TimeSpan.FromSeconds(5).Ticks); Assert.IsTrue(model.IsQueryRunning); Assert.IsFalse(model.ShowError); // Go beyond the failure point scheduler.AdvanceTo(TimeSpan.FromSeconds(16).Ticks); // Do we have an error ? Assert.IsFalse(model.IsQueryRunning); Assert.IsTrue(model.ShowError);
When the scheduler is created, it holds of all the scheduled operations until AdvanceTo is called. Then the scheduled actions are executed according to the virtual current time.
That way, your tests run at full speed, and you can test properly your time depedent code.
TLDR: This post talks about how the Reactive Extensions ObserveOn operator changes the execution context (the thread) of the IObservable OnNext/OnComplete/OnError methods, whereas the SubscribeOn operator changes the execution context of the implementation of the Subscribe method in the chain of observers. Both methods can be useful to improve the performance of an application's UI by putting work on background threads.
When developing asynchronous code, or consuming asynchronous APIs, you find yourself forced to use specific methods on a specific thread.
The most prominent examples being WPF/Silverlight and Winforms, where you cannot use UI bound types outside of the UI Thread. In the context of WPF, you'll find yourself forced to use the Dispatcher.Invoke method to manipulate the UI in the proper context.
However, you don't want to execute everything on the UI Thread, because the UI performance relies on it. Doing too much on the UI thread can lead to a very bad percieved performance, and angry users...
I've discussed a few times the use of ObserveOn in the context of WP7, where it is critical to leave the UI thread alone and avoid choppy animations, for instance.
The ObserveOn operator changes the context of execution (scheduler) of a chain of operators until an other operator changes it.
To be able to demonstrate this, let's write our own scheduler :
public class MyScheduler : IScheduler { // Warning: ThreadStatic is not supported on Windows Phone 7.0 and 7.1 // This code will not work properly on this platform. [ThreadStatic] public static int? SchedulerId; private int _schedulerId; private IScheduler _source; public MyScheduler(IScheduler source, int schedulerId) { _source = source; _schedulerId = schedulerId; } public DateTimeOffset Now { get { return _source.Now; } } public IDisposable Schedule<TState>( TState state, Func<IScheduler, TState, IDisposable> action ) { return _source.Schedule(state, WrapAction(action)); } private Func<IScheduler, TState, IDisposable> WrapAction<TState>( Func<IScheduler, TState, IDisposable> action) { return (scheduler, state) => { // Set the TLS with the proper ID SchedulerId = _schedulerId; return action(_source, state); }; } }
This scheduler's purpose is to intercept calls to the ISchedule methods (You'll fill the missing Schedule methods by yourself) and flag them with a custom thread ID. That way, we'll know which scheduler is executing our code.
Note that this code will not work properly on Windows Phone 7, since ThreadStaticAttribute is not supported. And it's still not supported on 7.1... Seems like not enough people are using ThreadStatic to make its way to the WP7 CLR...
Anyway, now if we write the following Rx expression :
Observable.Timer(TimeSpan.FromSeconds(1), new MyScheduler(Scheduler.ThreadPool, 42)) .Do(_ => Console.WriteLine(MyScheduler.SchedulerId)) .First();
We force the timer to raise OnNext on the ThreadPool through our scheduler, and we'll get the following :
Which means that the lambda passed as a parameter to the Do operator got executed in the context of the Scheduler used when declaring the Timer operator.
If we go a bit farther :
Observable.Timer(TimeSpan.FromSeconds(1), new MyScheduler(Scheduler.ThreadPool, 42)) .Do(_ => Console.WriteLine("Do(1): " + MyScheduler.SchedulerId)) .ObserveOn(new MyScheduler(Scheduler.ThreadPool, 43)) .Do(_ => Console.WriteLine("Do(2): " + MyScheduler.SchedulerId)) .ObserveOn(new MyScheduler(Scheduler.ThreadPool, 44)) .Do(_ => Console.WriteLine("Do(3): " + MyScheduler.SchedulerId)) .Do(_ => Console.WriteLine("Do(4): " + MyScheduler.SchedulerId)) .First();
We'll get the following :
Do(1): 42 Do(2): 43 Do(3): 44 Do(4): 44
Each time a scheduler was specified, the following operators OnNext delegates were executed on that scheduler.
In this case, we're using the Do operator which does not take a scheduler as a parameter. There some operators though, like Delay, that implicitly use a scheduler that changes the context.
Using this operator is particularly useful when the OnNext delegate is performing a context sensitive operation, like manipulating the UI, or when the source scheduler is the UI and the OnNext delegate is not related to the UI and can be executed on an other thread.
You'll find that operator handy with the WebClient or GeoCoordinateWatcher classes, which both execute their handlers on the UI thread. Watchout for Windows Phone 7.1 (mango) though, this may have changed a bit.
Using an Rx expression is performed in a least 5 stages :
The third part's execution context is covered by ObserveOn. But for the first two, this is different.
The expression is constructed like this :
var o = Observable.Timer(TimeSpan.FromSeconds(1));
Almost nothing's been executed here, just the creation of the observers for the entire expression, in a similar way IEnumerable expressions work. Until you call the IEnumerator.MoveNext, nothing is performed. In Rx expressions, until the Subscribe method is called, nothing is happening.
Then you can subscribe to the expression :
var d = o.Subscribe(_ => Console.WriteLine(_));
At this point, the whole chain of operators get their Subscribe method called, meaning they can start sending OnNext/OnError/OnComplete messages.
Then you meet that kind of expressions :
Observable .Return(42L) // Merge both enumerables into one, whichever the order of appearance .Merge( Observable.Timer( TimeSpan.FromSeconds(1), new MyScheduler(Scheduler.ThreadPool, 42) ) ) .Subscribe(_ => Console.WriteLine("Do(1): " + MyScheduler.SchedulerId)); Console.WriteLine("Subscribed !");
This expression will merge the two observables into one that will provide two values, one from Return and one from the timer.
And this is the output :
Do(1): Subscribed ! Do(1): 42
The Observable.Return OnNext was executed during the call to Subscribe, and has that thread has no SchedulerId, meaning that a whole lot of code has been executed in the context of the caller of Subscribe. You can imagine that if that expression is complex, and that the caller is the UI Thread, that can become a performance issue.
This is where the SubscribeOn operator becomes handy :
Observable .Return(42L) // Merge both enumerables into one, whichever the order of appearance .Merge( Observable.Timer( TimeSpan.FromSeconds(1), new MyScheduler(Scheduler.ThreadPool, 42) ) ) .SubscribeOn(new MyScheduler(Scheduler.ThreadPool, 43)) .Subscribe(_ => Console.WriteLine("Do(1): " + MyScheduler.SchedulerId)); Console.WriteLine("Subscribed !");
You then get this :
Subscribed ! Do(1): 43 Do(1): 42
The first OnNext is now executed under of a different scheduler, making subscribe a whole lot faster from the caller's point of view.
That might come in handy, but you may not want that as an opt-out because of this scenario :
Observable.FromEventPattern(textBox, "TextChanged") .SubscribeOn(new MyScheduler(Scheduler.ThreadPool, 43)) .Subscribe(_ => { }); Console.WriteLine("Subscribed !");
You'd get an "Invalid cross-thread access." System.UnauthorizedAccessException, because yo would try to add an event handler to a UI element from a different thread.
Interestingly though, this code does not work on WP7 but does on WPF 4.
An other scenario may be one where delaying the subscription may loose messages, so you need to make sure you're completely subscribed before raising events.
So there you have it :) I hope this helps you understand a bit better those two operators.
Building Windows Phone 7 applications in an agile way encourages the use of Continuous Integration, and that can be done using Team System 2010.
There are a few pitfalls to avoid to get there, but this can be acheived quite easily with great results.
I won't cover the goodness of automated builds, this has already been covered a lot.
Along with the continous integration to create hopefully successful builds out of every check-in of source code, you'll also find the automated execution of unit tests. Team System has the ability to provide nice code coverage and unit tests success rates in Reporting Services reports, where statistics can be viewed, which gives good health indicators of the project.
Unfortunately for us, at this point there are no ways to automatically execute tests using the WP7 .NET runtime. But if you successfuly use an MVVM approach, your view models and non UI code can be compiled for multiple platforms, because they do not rely on the UI components that may be specific to the WP7 platform. That way, we are still able to test our code using the .NET 4.0 runtime with MSTest and Visual Studio 2010 test projects.
To avoid repeating code, multi-targeted files can be integrated into single target projects either by :
Multi-targeted files are using the #if directive and the WINDOWS_PHONE define, or the lack thereof, to compile code for the current runtime target.
There is also the option of creating projects with the Portable Library add-in, but there are some caveats on that side, and there are a few constraints when using this method. You may need to externalize code that is not supported, like UrlDecode.
Testing with MSTest ensures that your code runs successfully on .NET 4.0 runtime, but this does not test on the WP7 runtime. So to be sure that your code is successfully running on it, and since Windows Phone 7 is build on Silverlight 3, tools like the SL3 Unit Test framework can be used to manually run tests in the emulator. This cannot be integrated into the build for now, unfortunately; you'll have to place that in your QA tests.
To be able to buid WP7 applications on your build machine, you need to install the SDK on your build machine, and a Team Build agent and/or controller.
Creating a build definition is done the same way as for any other build definition, except for one detail. You need to set the MSBuild platform to x86 instead of Auto if your build machine is running on a 64 Bits Windows. This forces the MSBuild runtime to use the 32 bits runtime, and not 64 bits, where the SDK does not work properly.
If you don't, when building your WP7 application, you'll find that intriguing message :
Could not load file or assembly 'System.Windows, Version=22.214.171.124'
Which is particularly odd considering that you've already installed the SDK, and that dll is definitely available.
You may also find that if you install that DLL from the SDK in the GAC, you'll get that other nice message :
Common Language Runtime detected an invalid program.
Which is most commonly found when mixing 32 bits and 64 bits assemblies, for which the architecture has been explicitly specified instead of "Any CPU". So don't install that DLL in the GAC and set the MSBuild architecture to x86.
That's it for now, and Happy WP7 building !
TL;DR: While trying to fix the "Black Screen" issue of the Windows Phone 7 flickr app 1.3, I found out that HttpWebRequest is internally making a synchronous call to the UI Thread, making a network call negatively impact the UI. The entire building of an asynchronous web query is performed on the UI thread, and you can't do anything about it.
Edit: This post was formerly named "About the UI Thread performance and HttpWebRequest", but was in fact about Yahoo's Flickr application and was enhanced accordingly.
When programming on Windows Phone 7, you'll hear often that to improve the perceived performance, you'll need to get off of the UI Thread (i.e. the dispatcher) to perform non UI related operations. By good perceived performance, I mean having the UI respond immediately, not stall when some background processing is done.
To acheive this, you'll need to use the common asynchrony techniques like queueing in the ThreadPool, create a new thread, or use the Begin/End pattern.
All of this is very true, and one very good example of bad UI Thread use is the processing of the body of a web request, particularly when using the WebClient where the raised events are in the context of the dispatcher. From a beginner's perspective, not having to care about changing contexts when developing a simple app that updates the UI, provides a particularly good and simple experience.
But that has the annoying effect of degrading the perceived performance of the application, because many parts of the application tend to run on the UI thread.
You'll find that the HttpWebRequest is a better choice in that regard. It uses the Begin/End pattern and the execution of the AsyncCallback is performed in the context of ThreadPool. This performs the execution of the code in that callback in a way that does not impact the perceived performance of the application.
Using the Reactive Extensions, this can be written like this :
var request = WebRequest.Create("http://www.google.com");
var queryBuilder = Observable.FromAsyncPattern( (h, o) => request.BeginGetResponse(h, o), ar => request.EndGetResponse(ar));
queryBuilder() /* Perform the expensive work in the context of the AsyncCall back */ /* from the WebRequest. This will be the ThreadPool. */ .Select(response => DoSomeExpensiveWork(response))
/* Go back to the UI Thread to execute the OnNext method on the subscriber */ .ObserveOnDispatcher() .Subscribe(result => DisplayResult(result));
That way, you'll get most of your code to execute out of the UI thread, where that does not impact the perceived performance of the application.
Actually, it will always be (as of Windows Phone NoDo), but there's a catch. And that's a big deal, from a performance perspective.
Consider this code :
public App() { /* some application initialization code */
ManualResetEvent ev = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem( d => { var r = WebRequest.Create("http://www.google.com"); r.BeginGetResponse((r2) => { }, null);
ev.Set(); } );
ev.WaitOne(); }
This code is basically beginning a request on the thread pool, while blocking the UI thread in the App.xaml.cs file. This makes the construction (but not the actual call on the network) of the WebRequest synchronous, and makes the application wait for the request to begin before showing any page to the user.
While this code is definitely not a best practice, there was a code path in the Flickr 1.3 application that was doing something remotely similar, in a more convoluted way. And if you try it for yourself, you'll find that the application hangs in a deadlock during the startup of the application, meaning that our event is never set.
If you dig a bit, you'll find that the stack trace for a thread in the thread pool is the following :
mscorlib.dll!System.PInvoke.PAL.Threading_Event_Wait() mscorlib.dll!System.Threading.EventWaitHandle.WaitOne() System.Windows.dll!System.Windows.Threading.Dispatcher.FastInvoke(...) System.Windows.dll!System.Net.Browser.AsyncHelper.BeginOnUI(...) System.Windows.dll!System.Net.Browser.ClientHttpWebRequest.BeginGetResponse(...) WindowsPhoneApplication2.dll!WindowsPhoneApplication2.App..ctor.AnonymousMethod__0(...)
The BeginGetResponse method is trying to execute something on the UI thread. And in our example, since the UI thread is blocked by the manual reset event, the application hangs in a deadlock between a resource in the dispatcher and our manual reset event.
This is also the case for the EndGetResponse method.
But if you dig even deeper, you'll find in the version of the System.Windows.dll assembly in the WP7 emulator (the one in the SDK is a stub for all public types), that the BeginGetResponse method is doing all the work of actually building the web query on the UI thread !
That is particularly disturbing. I'm still wondering why that network-only code would need to be executed to UI Thread.
The impact is fairly simple : The more web requests you make, the less your UI will be responsive, both for processing the beginning and the end of a web request. Each call to the methods BeginGetResponse and EndGetResponse implicitly goes to the UI thread.
In the case of Remote Control applications like mine that are trying to have remote mouse control, all are affected by the same lagging behavior of the mouse. That's partially because the UI thread is particularly busy processing Manipulation events, this explains a lot about the performance issues of the web requests performed at the same time, even by using HttpWebRequest instead of WebClient. This also explains why until the user stops touching the screen, the web requests will be strongly slowed down.
In the Flickr application for which I've been able to work on, a lot of people were reporting a "black screen" issue, where the application stopped working after a few days.
The application was actually trying to update a resource from the application startup in an asynchronous fashion using the HttpWebRequest. Because of a race condition with an other lock in the application and UI Thread that was waiting in the app's initialization, this resulted in an infinite "Black Screen" that could only be bypassed by reinstalling the application.
Interestingly enough, at this point in the application's initialization, in the App's class constructor, the application is not killed after 10 seconds if it is not showing a page to the user. However, if the application stalls in the constructor of the first page, the application is automatically killed by the OS after something like 10 seconds.
Regarding the use of the UI Thread inside the HttpWebRequest code, applications that are network intensive to get a lot of small web resources like images, this is has a negative impact on the performance. The UI thread is constantly interrupted to process network resources query and responses.
During the analysis of the emulator version of the System.Windows.dll assembly, I noticed that the BeginGetResponse is checking whether the current context is the UI Thread, and does not push the execution on the dispacther.
This means that if you can group the calls to BeginGetResponse calls in the UI thread, you'll spend less time switching between contexts. That's not the panacea, but at the very least you can gain on this side.
On the good news side, Scott Gu annouced at the Mix 11 that the manipulation events will be moved out the the UI thread, making the UI "buttery smooth" to take his words. This will a lot of applications benefit from this change.
Anyway, let's wait for Mango, I'm guessing that will this will change is a very positive way, and allow us to have high performance apps on the Windows Phone platform.
The Reactive Extensions have been included in Windows Phone 7, which comes out of the box, and that you can include the Microsoft.Phone.Reactive.dll assembly.
This is a good thing, because it participates in the democratization of the Rx framework, and aside from the fact that the namespace is not exactly the same as the desktop version, Microsoft.Phone.Reactive instead of System.Concurrency and System.Linq, there were no major bugs until recently.
A few applications I've worked on that use the Rx framework, a very interesting unhandled exception was popping-up from time to time in my exception tracker. Unlike the double tap issue I found the same way on my Remote Control application, that one was a bit more tricky, see for yourself :
Exception : System.NullReferenceException: NullReferenceException at Microsoft.Phone.Reactive.CurrentThreadScheduler.Trampoline.Run()at Microsoft.Phone.Reactive.CurrentThreadScheduler.EnsureTrampoline(Action action)at Microsoft.Phone.Reactive.AnonymousObservable`1.Subscribe(IObserver`1 observer)at Microsoft.Phone.Reactive.ObservableExtensions.Subscribe[TSource](IObservable`1 source, Action`1 onNext, Action`1 onError, Action onCompleted) at Microsoft.Phone.Reactive.ObservableExtensions.Subscribe[TSource](IObservable`1 source, Action`1 onNext)
This exception popped-up out of nowhere, without anything from the caller that would make that "Trampoline" method fail. No actual parameter passed to the Subscribe method was null, I made sure of that by using a precondition for calling Subscribe.
Well, it turns out that it's actually a bug that is related to the use of the infamous not-supported-but-silent ThreadStaticAttribute, for which I've had to work around to make umbrella work properly on Windows Phone 7.
The lack of a Thread Local Storage creates a concurrency issue around a priority queue that is kept by the CurrentThreadScheduler to perform delayed operations. The system wide queue was accessed by multiple threads at the same time, creating random NullReferenceExceptions.
This means that any call to the Subscribe method may have failed if an other call to that same method was being made at the same time.
In short, do not use the bundled version of Rx in Windows Phone 7 (as of NoDo), but prefer using the latest release from the DevLabs, which does not have this nasty bug.
I've been developing a free application to do some PC remote control on Windows Phone 7, and it's been very instructive in many ways.
To improve the quality of the software, and be notified when an unhandled exception occurs somewhere in my code, or in someone else's code executed on my behalf, I've added a small opt-in unhandled exception reporting feature. This basically sends me back information about the device, most of what's available in DeviceExtendedProperties for device aggregation of exceptions, plus some informations like the culture and, of course, the exception stacktrace and details.
A few recurring exceptions have popped up a lot recently, and one coming often is the following :
Exception : System.InvalidOperationException: Navigation is not allowed when the task is not in the foreground. Error: -2147220989 at Microsoft.Phone.Shell.Interop.ShellPageManagerNativeMethods.CheckHResult(Int32 hr) at Microsoft.Phone.Shell.Interop.ShellPageManager.NavigateToExternalPage(String pageUri, Byte[] args) at Microsoft.Phone.Tasks.ChooserHelper.Navigate(Uri appUri, ParameterPropertyBag ppb) at Microsoft.Phone.Tasks.MarketplaceLauncher.Show(MarketplaceContent content, MarketplaceOperation operation, String context) at Microsoft.Phone.Tasks.MarketplaceDetailTask.Show()
This code is called when a user clicks on the purchase image located on some page of the software, and it looks like this :
The call is performed directly on the image's ManipulationCompleted event.
I've been trying to reproduce it for a few times and I finally got it: The user is tapping more than once on the image.
I can see a few reasons why:
There may be actually more, be this actually tells me a lot.
First, I should be having some kind of visual feedback on the click of that image, to tell the user that he has done something (and also to actually follow the design guidelines)
Second, that even if the feedback is there, that there may always be two subsequent clicks, and one that may be executed after the first has called the MarketplaceDetailTask.Show(), and the application has been deactivated. I cannot do much about it, except handle the exception silently or track the actual application state and not call the method.
I'll go with the exception handler for now as it is not a very critical peace of code, but I'd rather have some way of that tell me that the application cannot do that reliably and not have to handle an exception. The API is rather limited on that side, where the PhoneApplicationService is only raising events and does not expose the current "activation" state.
I'll talk more about some other findings this opt-in exception reporting feature has brought me, with some that seem to be pretty tricky.
Cet article est disponible en français.
When developing .NET applications, unhandled exception in threads have the undesirable effect of terminating the current process.
In the following example :
static void Main(string[] args) { var t = new Thread(ThreadMethod); t.Start(); Console.ReadLine(); } private static void ThreadMethod() { Thread.Sleep(1000); throw new Exception(); }
The basic exception will invariably terminate the process, and to prevent this, the exception needs to be handled properly :
private static void ThreadMethod() { try { Thread.Sleep(1000); throw new Exception(); } catch (Exception e) { // TODO: Log and report the exception } }
This makes classes like System.Threading.Thread, System.Threading.Timer or System.Threading.ThreadPool very dangerous to use if one wants to have an always running application. It is then required that no unhandled exception gets out of the custom handlers for these classes.
Even if it is possible to be notified when an exception has been raised and not handled properly, using the AppDomain.UnhandledException event, most the time this leads to the application being terminated. This termination behavior has been introduced in .NET 2.0, to prevent unhandled exception to be silently ignored.
While this is a very appropriate default behavior, in an enterprise environment, I'm usually enforcing custom static analysis or NDepend rules to prevent the use of these classes directly. This forces new code to use wrappers that provide a very wide exception handler and logs and reports the exception, but does not terminate the process. That also implies that there is still a very valid bug to be investigated, because exceptions should not be handled that late.
In Silverlight for Windows Phone 7, and in any other .NET 3.5 or .NET 4.0 application that uses the Reactive Extensions, it is very easy to switch between threads.
Reactive operators like Timer, BufferWithTime, ObserveOn or SubscribeOn allow for specific Schedulers like ThreadPool, TaskPool or NewThread to be used, and if a subscriber does not handle exceptions properly, it ends up with a terminated application.
The same exemple here also terminates the application :
The Observable.Timer operator uses the System.Threading.Timer class and that makes it vulnerable to the same termination problems. Every subscriber needs to handle exceptions thrown in the OnNext delegate, or the application will terminate.
Also, do not think that the OnError delegate passed to Observable.Subscribe will handle exceptions thrown during the execution of OnNext code. OnError only notifies of errors generated by previous Reactive operators, not the current.
Unfortunately, it is not possible for now to override the default schedulers used internally by the Reactive operators. The only way to handle all unhandled exceptions properly is to use the ObserveOn operator and intercept calls to IScheduler.Schedule methods. Calls can then be decorated with appropriate exception handlers to log and report the exception without terminating the process.
So, to be able to generalize this logging and reporting behavior, I created the AsSafe() extension that I place at the very top of a Reactive expression :
Observable.Timer(TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(10)) .ObserveOn(Scheduler.ThreadPool.AsSafe()) .Subscribe(_=> ThreadMethod());
And here is the code of this very simple extension method :
Cet article est disponible en francais.
To continue in the same kind of articles about Visual Studio features that have been available for a while now, but are commonly under-used, I'll talk in this post about the Remote Debugger.
Visual Studio has a debugger that allows the debugging of program when running it using F5, or "Debug / Start Debugging". Visual Studio will then start in a special mode that allows step by step execution of the program, use features like BreakPoints, TracePoint, Watches, IntelliTrace, create MiniDumps and many more.
The debugger runs the program on the local machine, and uses the permissions of the locally logged on user.
Nothing out of the ordinary. Well, maybe the Reverse Debugging with IntelliTrace in VS2010, which is very cool.
I don't know about you, but I keep my development PC as stable as possible. I rarely install new software, so that I keep the overall performance stable over time. I will most of the time install new software versions only after having tested them on other PCs to determine their behavior.
Call me maniac, that's what it is :)
But then, what to do when the need for testing an installation program comes up ? Or when you need to debug plugins for NI TestStand or Labview ? Or when the software needs a very specific kind of hardware that cannot be installed on your development PC ? (Rainbow Keys, anyone ?)
The answer is simple : The Remote Debugger ! When possible, I will test and debug my software on a virtual machine, or on a physical machine that has the appropriate environment to execute the software.That way, the development environment stays stable, and I don't need to make installation of software that could add some crapware and eat up the few bytes of RAM left :)
The idea is to continue using the development machine, where the source code is and to connect via the network on a machine that will execute the program. After that, the remote debugging session is very similar to a local session, with the exception of the "Edit and Continue" that is not supported. But most of the time, we can live without it.
It is possible to run the execution on the remote machine by using the "Use Remote Machine" option in the "Debug" tab of a C# project. It is important to note that checking this option implies that all paths specified in "Working Directory" or "External Program" are those of the remote machine.
Aditionnally, Visual Studio will not copy the binaries and PDB files on the remote machine. You have to make the copy of the files at the appropriate location, by using a "Post Build Action", a UNC path in the form of "\\mymachine\c$\temp".
It is also possible to attach to a running process, by using the "Debug / Attach To Process" option. You just need to fill in the "Qualifier" and set the name of the remote debugger, and to choose the process to debug.
Quick hint: The option "Show processes from all users" is not enabled by default. This means that is you want to debug a Windows Service, you will not see it in the list until you enable it.Finally, the "Attach To Process" window is also very useful with local processes. It is a very handy feature to create a memory dump of a process that takes too much memory, and analyze it.
The Remote Debugger is an additional Visual Studio component that is located on the installation media, in the "Remote Debugger" folder. Three versions exist : x86, x64 and ia64 (RIP, Itanium...). If you have to debug a 32 process on 64 bits machine, I advise that you install both the x86 and x64 versions. You will have to choose which remote debugger to run depending on the .NET runtime that is used. You can see which version to use in the "Type" column of the "Attach to Process" window.
Here's what to do :
Note that the firewall on both the development and the remote machine can prevent the remote debugger from working properly. You can temporarily disable it, but make sure to enable it back after. If you only want to enable specific ports, the port 135/TCP is used. The Remote Debugger uses DCOM as its communication protocol.
This is a very common situation that means that the pdb files do not match the loaded binaries. Make sure that you've copied the pdb files at the same time you did the dlls.
The "Debug / Windows / Modules" shows if the debug symbols have been loaded properly, and if it's not the case, the "View / Output / Debug" window will most of the time show why.
Happy debugging !
We talk quite easily about new technologies and things we just learned about, because that's the way geeks work. But for newcomers, this is not always easy. This is a large recurring debate, but I find that it is good to step back from time to time and talk about good practices for these newcomers.
When we want to give a version to a .NET assembly, we can choose one of two common ways :
Most of the time, and by default in Visual Studio 2008 templates, we can find the AssemblyInfo.cs file in the Properties section of a project. This file will generally only contain an AssemblyVersion attribute, which will force the value of the AssemblyFileVersion value to the AssemblyVersion's value. The AssemblyFileVersion attribute is now added by default in the Visual Studio 2010 C# project templates, and this is a good thing.
It is possible to see the value of the AssemblyFileVersion attribute in file properties window the Windows file explorer, or by adding the "File Version" column, still in the Windows Explorer.
We can also find a automatic numbering provided by the C# compiler, by the use of :
[assembly: AssemblyVersion("1.0.0.*")]
Each new compilation will create a new version.
This feature is enough at first, but when you start having somehow complex projects, you may need to introduce continuous integration that will provide nightly builds. You will want to give a version to the assemblies in such a way it is easy to find which revision has been used in the source control system to compile those assemblies.
You can then modify the Team Build scripts to use tasks such as the AssemblyInfo task of MSBuild Tasks, and generate a new AssemblyInfo.cs file that will contain the proper version.
To come back to the subject of versionning an assembly properly, we generally want to know quickly, when a project build has been published, which version has been installed on the client's systems. Most of the time, we want to know which version is used because there is an issue, and that we will need to provide an updated assembly that will contain a fix. Particularly when the software cannot be reinstalled completely on those systems.
Lets consider that we have a solution with two assemblies signed with a strong name Assembly1 and Assembly2, with Assembly1 that uses types available in Assembly2, and that finally are versioned with an AssemblyVersion set to 126.96.36.1998. These assemblies are part of an official build published on the client's systems.
If we want to provide a fix in Assembly2, we will create a branch in the source control from the revision 220.127.116.118, and make the fix in that branch which will give revision 460, so the version 188.8.131.520.
If we let the Build System compile that revision, we will get assemblies that will be marked as 126.96.36.1990. If we only take Assembly2, and we place it on the client's systems, the CLR will refuse to load this new version if the assembly, because Assembly1 requires to have Assembly to of the version 18.104.22.1688. We can use the bindingRedirect parameter in the configuration file to get around that, but this is not always convenient, particularly when we update a lot of assemblies.
We can also compile this new version with the AssemblyVersion of 184.108.40.2060 set to 184.108.40.2068 for Assembly2, but this willl have the disadvantage of lying about the actual version of the file, and that will make diagnostics more complex in case of an other issue that could happen later.
To avoid having those issues with the resolution of assembly dependencies, it is possible to keep the AssemblyVersion constant, but use the AssemblyFileVersion to provide the actual version of the assembly.
The version specified in the AssemblyFileVersion is not used by the .NET Runtime, but is displayed in the file properties in the Windows Explorer.
We will then have the AssemlyVersion set to the original published version of the application, and set the AssemblyFileVersion to the same version, and later change only the AssemblyFileVersion when we published fixes of these assemblies.
Microsoft uses this technique to version the .NET runtime and BCL assemblies, and we take a look at System.dll for .NET 2.0, we can see that the AssemblyVersion is set to 126.96.36.199, and that the AssemblyFileVersion is set, for instance, to 2.0.50727.4927.
We can find other cases of loading issues linked to the mismatch of the version for a loaded assembly that is different from the expected assembly version.
WCF gives the developer a way to provide custom behaviors to alter the default behaviors for out-of-the-box bindings, and it is necessary to provide the fully qualified name, without errors. This is a pretty annoying but in WCF 4.x because it is somewhat complex to debug, and it is a very good case of use for the deactivation of "Just My Code" to find out why the assembly is not being loaded.
A good new though, this pretty old bug has been fixed in WCF 4.0 !
Some dynamic proxy generators like Castle Dynamic Proxy 2 or Spring.NET use fully qualified types to generate the code for the proxy's, and loading issues can occur if the assembly referenced by the proxy is not exactly what is being loaded, with or without a Strong Name. These frameworks are heavily used with AOP, or by frameworks nHibernate, ActiveRecords or iBatis.
To be a bit more precise, the use of the ProxyGenerator.CreateInterfaceProxyWithTarget method generates a proxy that targets the assembly that is referenced during the generation of the code for the proxied interface.To give an example, let's take an interface I1 in an assembly A1(184.108.40.206), which has a method that uses a type T1 in an assembly A2(188.8.131.52). If we change the assembly A2 and that its version becomes A2(188.8.131.52), the proxy will not be properly generated because the reference T1/A2(126.96.36.199) will be used because compiled in A1(188.8.131.52), regardless if we loaded A2(184.108.40.206)The best practice of not changing the AssemblyVersion avoid loading issues of this kind. These issues are not blocking, but this more work to do to get around it.
This is only a example of "Best Practice", which seems to have worked properly so far.
And you ? What do you do ? Which practices do you use to version your assemblies ?
My name is Jerome Laban, I am a Software Architect, C# MVP and .NET enthustiast from Montréal, QC. You will find my blog on this site, where I'm adding my thoughts on current events, or the things I'm working on, such as the Remote Control for Windows Phone.


text:
You are browsing the Subject Heading Environmental Protection/Advocacy Volunteer Opportunities which contains 14 record(s)
- Sierra Club-Santa Cruz County Group
The Santa Cruz Group of the Sierra Club provides monthly programs and outings, and serves as a voice for the local environments of Santa Cruz County. The Santa Cruz Group offers residents opportunitie... [Full Record] [Add to Personal List]
- Surfrider Foundation, Santa Cruz Chapter
The Surfrider Foundation is a non-profit grassroots organization dedicated to the protection and enjoyment of our world's oceans, waves and beaches. Founded in 1984 by a handful of visionary surf... [Full Record]
- The Manta Network
This non-profit is the first International Organization dedicated to the protection and conservation of Manta birostris worldwide. ... [Full Record] [Add to Personal List]
- Ventana Wilderness Alliance
Founded in the summer of 1998, the Ventana Wilderness Alliance is a California nonprofit corporation with IRS 501(c)(3) tax-exempt status dedicated to protecting the wildlands of California's nor... [Full Record] [Add to Personal List]

subset: commoncrawl


text:
in Rockville, MD
5 attending
in Washington, DC
19 attending
Fun Korean Waves ™ Culture Language ESL Music Food, DC VA MD
in Washington, dc
13 attending · 2 waiting
in Fort George G Meade, MD
54 attending · 41 waiting
7 Meetup Groups match "Japanese Food" near Gambrills, MD
Meetup details are available only to members.
The Asian Dining Group is a group who adore all kinds of Asian Cuisine e.g. Chinese, Thai, Korean, Vietnamese, Indian, Japanese, Taiwanese, etc. Folks that like to dine out and try new things. Then this group is for you! Learn about Chinese, Korean, Japanese, Taiwanese, Cantonese culture, et. al. No shows will be documented and removed from the group. Late drop is considered a no show. Please read the group rules: http://www.meetup.com/Asian-Dining/about/
There are no upcoming Meetups.
Meet other locals who are interested in exploring many aspects of green living. The main topics we will cover are health, fitness, nature, organic gardening, green home, renewable energy, green transportation, and spirituality. Health includes potlucks, dining out, food preparation classes, discussions, etc. that explore the healthiest and tastiest diets available such as organic food, raw food, vegan, vegetarian, macrobiotic, and Japanese food. Our Fitness and Nature meetups will allow us oppor …
The weekend is over and the work week has begun. It's Tuesday night and I want Sushi! If you are 40 and older, and love the atmosphere of Japanese restaurants, and the enjoyment of ordering sushi and sashimi and other a la carte foods, then here's a meetup for you. Let's explore the various tasty and affordable sushi restaurants in Maryland - mostly Bethesda, Rockville and Silver Spring. (and maybe other nearby places too!) Meet new friends and enjoy a relaxed dinner out. Hope to see you there.
Hello! This successful international culture group in Washington DC, Maryland & Virginia (& Korea!), founded in 2006, has over 1300 members. We celebrated our 7th anniversary in 2013! Korean Waves ™ in 2012 & 2013 went GANGNAM STYLE (강남스타일) in DC, VA, & MD! The Korean cultural sensation - Korean singer Psy - and now international star inspired many of us with his hit song (oppan) Gangnam Style. Join a group that includes its own stars... our members! And yes, we do have stars at some of our …
This group is for young Asian professionals or anyone who enjoys being part of the group in their 20s and 30s. If you like dancing, drinking, socializing, going out or love taken pictures, please join and we will keep you update on our monthly plans. We plan happy hours, events and activities in many of DC popular clubs, lounges and locations for people to meet, make new friends and a change to network. This group is open for single, married, new comers, college students, foreign students and an …
There are no upcoming Meetups.
Welcome to the Asian Cultures meetup. Explore the cultures of asia, including Chinese, Japanese, Korean, Thai, Vietnamese, and more.
There are no upcoming Meetups.
Are you familiar with words like parallel-twins, singles, triples, carbs, drum brakes, points, condensers, magneto's, clubman's, piss catchers, and Doing the Ton? Do you like vintage British , European, Japanese, and modern retro? This is a group for vintage motorcycles riders who love to ride a slow bike fast and maybe have some food and adult beverages after. This is not club, but a way to get like minded vintage motorcycles riders together (safety in numbers), learn some tips and tricks on ke …
Get an alert email when new Meetup Groups like this start near you.
You'll get advice, help finding members, and tools to make running a Meetup Group easier.


text:
I want to use CJC + GHRP-6 for mass building.
I thought about 1mg CJC per Week and 150mcg GHRP-6 twice a day.
What do you think about this?
or how would it be better to use?
you can used it every 3 hours (w/out DAC version)as many times as you have time for in the day. 2x daily works....5 x daily works better.


text:
- Home
- > Shop
- >
- Grocery
- >
- Snacks
- > Granola & Bars
KIND Fruit + Nut Nutrition Bars Apple Cinnamon & Pecan
5.0 1.0$19.99
Size/Count 12.0 ea
- Prevent weight gain eat a KIND bar
- Delicious and only 180 calories
- Made with all natural ingredientsmore
Receiving Options
- All Natural / Non GMO
- Gluten & Wheat Free
- Good Source of Fiber
- No Trans Fats
- Dairy Free
- Cholesterol Free
- Very Low Sodium
- No Sulphur Dioxide
- No Hydrogenated Oil
- 2.5g fiber
- 3g protein
- Only 180 calories
Ingredients you can see & pronounce®
Finally, a delicious bar with only 180 calories made from all natural ingredients you see and pronounce!®
Its nutritionally rich, low glycemic, delicious ingredients - with 2.5g of fiber and 3g of protein - keep you fuller longer. A study by the Yale-Griffin Prevention Research Center indicates that eating 2 KIND bars a day helps prevent weight gain.
Do the KIND Thing - for your body, your taste buds & the world!®
Welcome to the KIND community! Here at KIND we do things differently and try to avoid false compromises. Instead of "or" we say "and." We choose healthy and tasty, convenient and wholesome, economically sustainable and socially impactful. We call this the KIND brAND philosophy.™ Our goal is to make KIND not just a brand of healthy smacks and foods, but also a state of mind and community of KINDAHOLICS - people with an uncontrollable love for KIND and spreading kindness!
KINDLY Yours,
Daniel Lubetzky, KIND Founder & CEO
Do the KIND Thing - for your body!®
At KIND we crafted delicious, all-natural healthful foods made from ingredients you can see and pronounce®. We use whole nuts and fruit and bind them together with honey through a natural process so they achieve just the right crunch.
KIND Apple Cinnamon & Pecan:
So go on, have your KIND and eat it too!™
Do the KIND Thing - for your taste buds!®
Try our other award-winning, all natural healthy snacks and foods made from ingredients you can see & pronounce,® including our newest offering - KIND Healthy Grains. KIND Healthy Grains are delicious, snackable clusters made of 100% whole grains and tasty superfoods, hand-crafted to give you more health benefits in every bite!
Enjoy them any time of day by the handful, with yogurt or with milk!
Do the KIND Thing - for the world!®
At KIND, we like to say, "it's usually the nuts that change the world."® That's why we work hard to make the world a little kinder through all that we do and how we do it - from the healthy snacks and foods we make, to the way we work, live and give back. We call this the KIND Movement, which has inspired thousands of unexpected acts of kindness around the world.
Sustainable Forestry Initiative® ~ Certified Chain of Custody: Promoting Sustainable Forest Management
12 - 1.4 oz (40g) Bars ~ Net Wt 16.8 oz (480g)
Made in the USA
Store in a cool, dry place.
Shipping Weight (in lbs): 1.35 Product in inches (LxWxH): 6.2x 6.6x 2.5
Item Code: 238087
Allergen information: Manufactured in a facility that uses peanuts, brazil nuts, walnuts, almonds, sesame seeds, and soy. May contain nut shell fragments.
Dried AppleApples, Sugar) , Almonds , Cashew Nut , Pecans , Raisins , Honey , Non GMO Glucose , Crisp Rice , Chicory Fiber , Flaxseed (Linum Usitatissimum) , Soy Lecithin , Cinnamon (Cinnamomum Cassia)
Nutrition Facts | ||
Serving Size : 1 Bar Serving per Container : 12 |
Amount Per Serving | % Daily value* | |
Total Fat 11 g | 17 | |
Saturated Fat 1.5 g | 8 | |
Sodium 30 mg | 1 | |
Potassium 150 mg | 4 | |
Total Carbohydrate 18 g | 6 | |
Dietary fiber 4 g | 16 | |
Sugars 10 g | ||
Protein 7 g | ||
Vitamin C mg | 2 | |
Calcium mg | 4 | |
Iron mg | 6 | |
Calories 190 Calories | ||
Calories From Fat 100 Calories |


text:
Think about it. Media literacy no longer protects "only" the quality of the information we take in. It now protects our relationships and even our identities – on several levels. It's an understatement to say we need to be media literate more than ever now. I've posted plenty about the relationships part (social literacy), so […]
Profanity Filter
by Inversoft


text:
The Seven Desires of Every Heart
Price: | $19.99 |
Buy From Zondervan
Choose a Retailer Below
In this instructive and inspirational book, Mark and Debra Laaser teach us how to have richer relationships with God and others. Using stories and straightforward observations, they examine seven desires we all share, and illustrate how understanding those desires can enhance our relationships and enrich our lives.
Download - Audio, Unabridged$19.99
ePub, Reflowable$10.99
A deeper probe into relationships starts with our heart's desires
At last, a "relationship book" that looks past what separates us to examine what connects us!
Dr. Mark and Debra Laaser go to the heart of the matter. Instead of focusing on how to sidestep or compensate for perceived differences, they dig deeper, to the core of our souls, to examine how the basic desires and needs of all people make us more alike than different.
The Seven Desires of Every Heart explores the common desires God gives you---to be heard, affirmed, blessed, safe, touched, chosen, and included. Using stories, Biblical references, and sound psychological principles, the Laasers explain each desire and show us how we seek it and what it feels like to have it truly fulfilled. You also will learn healthy ways to embody these desires in your relationships. You will be given the tools you need to start repairing and rebuilding relationships and developing new skills for creating emotional and spiritual intimacy.


text:
- Home
- >
- Worship & Music
- >
- Welcome to Worship & Music
Welcome to Worship & Music
"Great is the Lord, and greatly to be praised, and his greatness is unsearchable" (Psalm 145:3). We were created to worship our great God with every day we live and every breath we breathe. One of the ways we celebrate and encounter God's greatness is to gather together every week to sing to him, to hear from his word, and to cherish his presence. Please click on the links above to find out more about worship and music at The Falls Church Anglican.


text:
CHAMPION Men's Uphold Dazzle Basketball Jacket
Eligible Free Shipping on Shoes, Clothes & Fan Gear! (see promotion details) |
Eligible for Free Shipping on Orders $49 or More! (see promotion details) |
Members of The League get 5% back when you spend $100! (see promotion details) |
Product Details
This CHAMPION® men's Uphold Dazzle basketball full-zip jacket is one top you won't mind throwing on after a grueling practice or game. The lightweight fabric is heavy enough to ward off cool air without weighing you down, and it has a pair of side-seam pockets to keep valuable stuff close by. The mock-neck collar is lined for added comfort, and mesh inserts are featured on each side to help you cool off when you're fresh off the hardwood.
Features- 100% polyester
- Full-zip jacket
- CHAMPION� brandmark on left chest and upper back
- Mock-neck collar with mesh lining
- Elastic cuffs and waistband
- Interior neck taping
- 2 side-seam pockets
- Mesh side inserts for added breathability
- Contrast panels on sleeves and sides
- Made in Cambodia


text:
Skip to Content
Search All Programs & Services
Search by Name, Specialty, Program, or Research.
Make a Donation
Thousands of patients come to us from around the world to team with our expert physicians and researchers and seek treatment for respiratory, cardiac, immune and related conditions.
Learn about our programs For Professionals Allergy and Clinical Immunology Asthma Cardiology COPD Critical Care and Hospital Medicine Environmental and Occupational Health Gastroenterology Interstitial Lung Disease (ILD) Mycobacterial and Respiratory Infections Nephrology & Diabetology Oncology Rehabilitation Respiratory Treatment Rheumatology Sleep Allergy and Clinical Immunology Asthma Atopic Dermatitis (Eczema) Behavioral Health Behavioral Sleep Services Exercise Tolerance Food Allergy Respiratory Medicine Radiology Nursing Support Groups
Avoid these ingredients to keep your holidays merry and bright.
U.S. Pro Snowboarders go behind the scenes.
How to control your portion size.
Our QuitLine experts give you support to quit smoking.
Tips for the new year to achieve a new you.
The "invisibility cloak" isn't just Harry Potter's.
Bronchial Thermoplasty Shows Long-Term Effectiveness for Asthma12/02/2013National Jewish HealthReducing Salt in Your Diet a Challenge: Here Are Some Tips10/29/2013Denver Post
Managing Your Energy Every DayDenver, CO
Nutrition and Heart HealthDenver, CO
Search All EventsView Support Groups
Colorado Gives Day Dec. 10Support National Jewish Health on Colorado Gives Day on Dec. 10. You don't have to live in Colorado — anyone can give online.
Make ADonation
Back To Top
© 2013 National Jewish Health


text:
Michael E. Webber is on the faculty at the University of Texas at Austin. Marianne Shivers Gonzalez is a researcher at the University of Texas at Austin. Juan Garcia is the producer of Energy at the Movies.
Have comments or energy movie suggestions? Email us at email@example.com
Dr. Michael E. Webber
Josey Centennial Fellow in Energy Resources
Associate Professor, Mechanical Engineering
Deputy Director, Energy Institute
Co-Director, Clean Energy Incubator
The University of Texas at Austin
Read More
Energy at the Movies: From Campus to Primetime
Dr. Michael Webber and Juan Garcia present at SXSW Edu in March 2014.
UT Professor's Energy a TV Hit
The Austin American-Statesman, Laylan Copelin
"When Energy Goes Hollywood: A Conversation with Michael Webber"
StateImpact Texas, Terrence Henry, KUT Austin
"'The Power of Cinema: UT Professor Uses Film as Teaching Tool for the Masses about Energy in Society"
Austin Business Journal, James Jeffrey
© 2013 Michael Webber and Energy at the Movies All Rights Reserved


text:
The dictionary defines pigeon-toed as "having the toes turned inward." No such colorful term can be found for feet that point outward. Both of these foot problems can be caused by a problem that doctors call torsional deformities. This is when the long bones of the leg are turned to the inside or outside so that the toes of the feet do not point straight ahead. Either of the two main bones in the leg can be affected -- the femur (between the hip and the knee) or the tibia (the larger of the two bones between the knee and the ankle). One or both legs can be affected.
Torsional deformities can lead to toes that point inward (in-toeing) or toes that point outward (out-toeing). Parents often worry that in-toeing or out-toeing will permanently interfere with their child's ability to walk and run normally. However, in most young children, in-toeing or out-toeing is caused by a torsional deformity that appears for a short period, and then disappears during the normal stages of leg development. Most torsional deformities are temporary and correct themselves by age six to eight. In rare cases, in-toeing or out-toeing is a sign of a permanent bone deformity or other problem that requires medical attention.
These conditions may be related to one or more of the following factors:
The most common type of torsional deformity in toddlers is when the tibia (in the lower leg) is rotated inward, leading to in-toeing. This is caused by the child's position in the uterus before birth and usually is seen in children younger than 2. As the body works to correct this problem during development, the tibia sometimes can turn too far in the opposite direction and become rotated outward. This can cause out-toeing, but the condition usually is temporary and will go away as the child develops.
The most common cause of in-toeing in older children is when the femur (in the upper leg) is rotated inward. This is more common in girls than boys and usually is seen in children three to six years old. In most cases, the cause is unknown. Some experts believe that it is related to a child's position in the uterus before birth. Others blame it on a child's position while sitting or sleeping. For example, children seem to be at higher risk of developing this problem if they frequently sit with their knees pointed forward and touching and their legs folded under, splayed to either side (in the "W" position). In rare cases, this condition is caused by neuromuscular disorders, such as cerebral palsy.
Out-toeing due to an abnormal outward rotation of the femur is uncommon. The cause of this condition is unknown, but it probably is related to positioning of the legs before and after birth and usually affects both legs. In rare cases, out-toeing is seen in only one leg and may be a sign of a serious problem with the upper part of the femur bone called slipped capital femoral epiphysis.
Childhood torsional deformities usually are painless. The child usually does not notice the problem, and it typically does not interfere with the child's ability to walk, run and play normally.
The doctor will review your child's symptoms, family history and medical history. The doctor may ask the following:
Then the doctor will examine your child, looking at:
In most cases, the doctor can make a final diagnosis based on your child's age and history, together with the results of a thorough physical examination. X-rays usually are not necessary.
Almost all torsional deformities are short-term conditions that go away before a child reaches adulthood. For example, inward rotation of the tibia usually disappears by the time a child is 3 or 4 years old, and inward rotation of the femur usually goes away before age 10.
Most cases of torsional deformity represent predictable stages of development and cannot be prevented. However, in some cases, sitting or sleeping in certain positions may worsen these problems. Your doctor may have suggestions regarding exercises or positions that may help to minimize any torsion.
In most cases, doctors do not treat torsional deformities because these conditions usually disappear as children grow older. In very rare cases, when in-toeing or out-toeing is caused by a bone deformity, surgery may be necessary to correct the problem.
Call your pediatrician or family doctor if you have any concerns about the way your child walks or runs, especially if your child seems to trip or fall more often than other children of the same age.
The outlook is excellent. The majority of torsional deformities go away before adolescence.
American Academy of Orthopaedic Surgeons (AAOS)
6300 North River Road
Rosemont, IL 60018-4262
Phone: 847-823-7186
Fax: 847-823-8125
American Academy of Pediatrics (AAP)
141 Northwest Point Blvd.
Elk Grove Village, IL 60007-1098
Phone: 847-434-4000
Fax: 847-434-8000


text:
- Also Known As:
- Admiral Suites Bangkok Hotel
- Admiral Suites Bangkok Hotel Bangkok
- Admiral Hotel Bangkok
- Bangkok Admiral Hotel
Thailand >
Business Centre
Fitness Centre
Free Breakfast
Free High-Speed Internet
Free Parking
Room Service
Shuttle Bus service
Swimming Pool
#143 Business Hotel in Bangkok
Price range (per night):
Hotel Class:3.5 star — Admiral Suites Bangkok 3.5*
- Official Description (provided by the hotel):
- Admiral Suites is situated in the heart of Sukhumvit Road, Bangkok's prime commercial and residential street. The hotel is ideally located for business and / or leisure, and guarantee the highest level of personalized service. It is only 5-10 minutes walking away to reach BTS Station, Emporium Mall, Benjasiri Park, and wide selections of dining and shopping. ... more less
- Reservation Options:
- TripAdvisor is proud to partner with Hotels.com, Booking.com, Expedia, Orbitz, Asiatravel.com Holdings, Agoda, Cheap Tickets, HostelBookers, Priceline, Olotels, HotelTravel.com, Venere, Tingo and Otel so you can book your Admiral Suites Bangkok reservations with confidence. We help millions of travellers each month to find the perfect hotel for both holiday and business trips, always with the best discounts and special offers.


text:
A Different Drummer
Vic Firth has built the largest drumstick empire on the planet.
Photograph by Jennifer Baum
From a factory in Newport, musician Vic Firth has built the largest drumstick empire on the planet and in the process changed the sound of music from jazz to classical to pop. Not bad for a smart-aleck kid from Sanford.
When Vic Firth was a boy learning how to play the drums in the 1940s, there was a right way and a wrong way to hold the sticks. The right way was called the traditional grip, and it meant holding the drumstick in the left hand between the second and third fingers so that the pair of sticks on the drumhead would almost form a right angle. This took some getting used to, and a lot of young drummers would end up hitting the drum harder with one hand than the other, making some rhythms come out sounding a little stilted.
Clever guy that he was, Firth soon figured out that the issue was not the drummer or the grip. "It wasn't the left hand that was the problem," he says. "It was that the sticks were different sizes." One was often much heavier than the other. Back then there was no such thing as pairing sticks by weight, never mind by pitch, so that both sticks resonate at the same frequency.
Vic Firth would change all that. As a young teacher at the New England Conservatory of Music in Boston, he made an arrangement with a wood turner in Montreal to produce custom sticks, and in so doing he created a drumstick empire that also made Vic Firth a living legend.
Being the principal timpanist of the Boston Symphony Orchestra (BSO) didn't hurt. A native of Sanford, Firth was the youngest musician to become a principal and the longest tenured performer with the world-renowned symphony, pounding out rhythms well into his seventies. He's played for or with an amazing array of greats — from Leonard Bernstein to Arthur Fiedler to Chet Atkins to Tony Bennett — and his innovations in drumstick design revolutionized the world of drumming.
At his factory in Newport Firth tells his story to a couple of visitors. Hard by the shore of Sebasticook Lake in central Maine, the facility gets its share of guests because of its state-of-the-art production processes. At seventy-eight, Firth is full of stories, and he's gracious and old-school enough to share them, with a charisma not unlike that of Frank Sinatra. He leans in to make eye contact, sitting in the modest boardroom at his mill, and has something of a Boston accent, which is understandable since he has spent most of his life playing and teaching in Beantown, the world headquarters of Vic Firth Incorporated.
But there's a lot of the Maine boy still in Vic Firth. Although he now lives in Dover, New Hampshire, he was raised in Sanford and still has a seasonal place in the Yorks. He likes few things better than to fish for mackerel and bluefish off his boat, something he did with his father, who worked as a music teacher in Wells, Kennebunk, and Exeter, New Hampshire. The senior Firth was a trumpet player, and Little Vic — Everett to family — had his first cornet at age four. "I had the worst embouchure, the worst sound," he says with characteristic self-deprecation.
So at about age ten Firth ended up going to see a drum teacher who was a family friend. His father saw to it that he was well versed in other instruments — piano, cornet, trumpet, trombone — as well as theory — "only to learn orchestration," he says. By his teens he was playing dances, running his own eighteen-piece big band and booking performances all over New England. This was the World War II era, and Sanford had a big airstrip. "There might be 18,000 sailors around," Firth says. "I'd be playing dances with these older guys — it was wild, everyone was drinking except me — from 9 p.m. to 3 a.m. and then I'd get up and go to school at 8 a.m."
While studying at the New England Conservatory of Music, Firth won a scholarship to attend Tanglewood. "There was a [charitable] club that awarded a scholarship for a Maine student to go," he recalls, "usually a singer or a flutist. Drummers were at the bottom of the list. But that year there was no one but me suited to go."
It was at the Boston Symphony Orchestra's vaunted summer retreat that Vic Firth went from being a jazz boy to a classical kid. "The symphonic side fascinated me," he says. And he practiced it obsessively. "If I had a day when I practiced less than eight hours, it was a bad day."
Firth's dedication — and his rhythmic chops — took him straight from school to the big time. "It was a shocker," he says, to be accepted into one of the world's great orchestras at the tender age of twenty. At the time the average age of his colleagues was fifty-five. "Most of the players then were Europeans," he explains. "And here I was some punk kid from Maine that most of them had never heard of."
One very important person was aware of this talent from Maine, however. "It all started with Arthur Fiedler, who'd heard of me and asked me to audition for the Pops," remembers Firth.
Of course, like any other kid barely out of his teens, Firth wasn't sure what he really wanted to do. "I was offered a job as a cymbalist and turned it down." He chuckles. His father wasn't amused, encouraging him to rethink his choice. The savvy young Firth went back to the bargaining table. "I didn't want to play cymbals," he says. After a bit of back and forth — that kind of negotiating was unheard of at the time, especially by someone so young — Firth walked out with a deal in his favor. "I agreed to be a percussionist," he says. Then he smiles. "But only for a year."
That year never ended. Firth played with the orchestra. He played with the Pops. He played at Tanglewood. He recorded with Fiedler, Charles Munch, Seiji Ozawa, and Leonard Bernstein. "I saw more players, managers, and conductors than you can imagine," he says.
And just as his father had before him — and orchestra players have everywhere — he began teaching. Between the BSO and the New England Conservatory of Music, his world revolved around drumsticks.
If Vic Firth's development into a world-class musician seemed almost inevitable, the rise of Vic Firth Incorporated came about almost by accident. In the fifties, Firth was playing with whatever sticks were available. But he was not particularly happy with them. "The tools needed improving," he recalls. "They were never good enough. I was always complaining about them, and one day I decided to stop complaining and do something about it. So I found a wood turner in Montreal, and I ordered ten pairs of sticks for personal use."
At the time, Firth was teaching at the conservatory, and his new sticks caught the attention of his students. "Everyone saw them and said, 'Can I buy a pair from you?' I said, 'No, but next time I place an order I'll get some for you, too.' " He got a lot of these requests.
And then one day a really large order came in. "Drummers are strange guys, and they have a special fraternity," he says. "You never hear of trumpet shops or flute shops but there are drum shops all over the place." Somehow just such a shop in Chicago heard about Firth's sticks and asked if it too could place an order. "From there I started to get orders from drum shops everywhere."
Suddenly he found himself with a company. "I think my best ability at that time was ignorance," he jokes. "Here I was without any knowledge of marketing or sales or manufacturing." As his orders got larger, his man in Montreal grew too expensive, and Firth began to look around for another manufacturing facility. And if you're searching for wood workers, where better to look than in Maine? Firth found the craftsmen he needed in Kingfield, and his young company soon found itself turning out thousands upon thousands of drumsticks.
Not just any drumsticks either. Because he was so unhappy with the sticks he'd used previously, Firth wanted to make sure his products were of the highest quality. This meant a raft of innovations thatleft his competition in the sawdust.
First, there was the issue of weight. Vic Firth insisted that his sticks be sorted and paired by their weight. He demanded that they be straight, too, which seems rather obvious but was unheard of previously. "The boss of the biggest drumstick company at the time said to me: 'You can't guarantee that two pieces of wood will be straight. How can you even tell?' " Firth's sticks would carry just such a guarantee. And he wanted them all to be sorted and paired by pitch, as well, so that they resonated at the same frequency. Again, this was unprecedented.
This idea of pitch also came to him by chance. One day he was carrying some sticks and dropped them on a cement floor. When they hit, he noticed that they all sounded different. He picked them up and let them fall again, hearing the same thing. No good. They'd have to be paired by sound as well as weight. He had all sorts of ways of doing this at first. He first tried to make a cement form, but it didn't sound the way the floor did. Then he moved on to using two gravestones to test the sticks — purchased from a guy in South Berwick — doubling up sticks by hand. These days the sticks are rapped by a tiny hammer, studied by a computer, and then placed into bins by the pitch at which they vibrate.
With each of these innovations, Vic Firth's status grew, and so did his company. By the nineties, even with a full-scale factory in Kingfield, he was having a hard time keeping up with all the orders. So Vic Firth expanded to the Newport facility he currently occupies, keeping both going for a while, then moving out of Kingfield altogether.
It's difficult to overstate what a phenomenon Vic Firth Incorporated was becoming. It was soon the largest drumstick manufacturer on the planet, selling 12 million pairs a year in more than 400 different styles to more than 126 countries worldwide. The company owns 60 percent of the marketshare, and has gone from employing fifty-nine people in 2001 to 180 today. And it has many of the world's greatest drummers as endorsees.
It also keeps Firth busy. For decades, he would report to his office in Boston at 7:30 a.m., leave to attend a ten o'clock rehearsal with the BSO, head to the conservatory to teach all afternoon, and then play a concert at night. "I used to put in a lot of fifteen- or sixteen-hour days," he says. "That's why I go at the pace I do today."
He's been married to the same woman, Olga, for forty-six years, and the couple raised two daughters, Kelly and Tracy. Tracy is an important part of the business now as chief operations officer at Vic Firth Incorporated. Firth himself officially retired from the BSO five years ago but his days are no less busy.
Today Vic Firth Incorporated also makes rolling pins and gourmet pepper mills, including a signature line for celebrity chef Mario Batali.
But drumsticks remain the center of the business, and the process by which a hickory dowel becomes a custom Vic Firth stick is rather amazing. Vice President of Manufacturing Mike Gault walks his visitors through the stages. First, the Appalachian hickory is trucked in from Kentucky and Tennessee and dried in one of seven kilns. The wood is reduced in five different steps, going through as many machines, to reach the size of a stick. "Most of our competitors do it in one step," says Gault. "But that puts a lot of stress on the wood. We've adopted a method similar to making pool cues, which means a series of small cuts so they don't stress the wood. And we're still doing it faster."
After being reduced twice, a laser checks the wood for straightness. Then it's sanded and the finish is applied. The sticks are sorted for weight, pitch, size, and checked for straightness two more times. Each one is individually inspected.
"People see this pair of sticks and they don't realize what we go through to get this," Firth says. "Then we give them to some guy with green pants and purple hair and a tattoo on the inside of his nose, and he breaks it in five beats."
And with that thought, Vic Firth flashes a wide grin.
- By: Andrew Vietze


text:
Love Reign O'er Tulsa
Classic band revisits groundbreaking rock opera
When the announcement came last year that The Who would be visiting Tulsa in 2013, I (along with many other rock fans) rejoiced. When I saw the date, however, I did something of a double take.
While the arrival of rock legends and hall of famers Pete Townshend and Roger Daltrey is worth celebration -- especially as they roll out a full production of Quadrophenia for its 40th anniversary -- booking the band on Feb. 14 seemed peculiar at best. In the back of my mind I could immediately picture the excitement of men everywhere at the chance to see The Who once again -- and the frustration of wives and girlfriends across town at the prospect of losing roses and a fine dinner for a thundering, loud rock concert. Fortunately for me, that's not an issue, but I digress ...
While booking The Who on Valentine's Day may not be the most romantic date in the books, it's definitely appropriate in that The Who is a band many classic rock fans have always loved. Revered as rock legends, Townshend's songwriting has always been as strong as -- if not ahead of -- his peers. When paired with the power of Daltrey's voice -- which for many classic rock fans is only rivaled by Robert Plant -- The Who at its peak was nearly a force of nature. Somehow, however, the group always seemed to be overshadowed by its peers, The Beatles and The Rolling Stones.
While the 1968 rock opera Tommy truly set The Who apart and established the band's status as an elite rock band, many would argue that it wasn't necessarily the band's finest moment or Townshend's crowning achievement. For a large segment of fans, Townshend perfected his storytelling skills and Daltrey gave one of his finest performances nearly five years later with the rock opera Quadrophenia.
The Who revived its seminal work in 1997 with a tour that saw the band play Quadrophenia in its entirety for the album's 25th anniversary. Last year, Townshend and Daltrey hit the road once more to give the album one more visit in a show that has continued to keep fans old and new enthralled.
When asked last year why he thought the music and themes of Quadrophenia (both the album and film adaptation) still resonate so strongly today, Townshend proved to be both reflective and insightful.
"In 1972, I was 28, writing about London and Brighton in 1963 and 1964 when the band was just starting," he said. "I was still young enough to remember how it felt to be 16 or 17 and at war with my parents, bosses, and authority. I could still remember that feeling of struggling to fit in, something that happened to me when I was even younger, around 14, and everyone around me seemed to have gotten their lives on track. This is such a universal experience for young people that it has echoed."
Indeed, the themes of alienation, class wars, and trying to fit in all resonate universally, regardless of the decade or if you grew up in England or the United States. Finding your place in life, along with acceptance and love is what everyone searches for on one level or another and the completion of that cycle as Quadrophenia closed with "The Rock" and "Love Reign O'er Me" not only drew the album to a close with a visceral high point, but also the resolution that everyone strives for.
Some 40 years later, however, listening habits have changed, and in the age of the iPod, many music fans are more single-oriented and not as interested in full albums. Meanwhile, as music and fashion tend to go in cycles and the album as an art form is starting to cycle back around, older fans crave the full experience. Classic acts have started performing their older albums in full, as The Who is with its current tour.
In July, "Raise the Question" asked Townshend: "In this single-driven digital age, there are artists now singing the praises of the album as an art form and playing their own albums from front to back on stage. Since Quadrophenia represents the album aesthetic in its highest form, what are your thoughts about the importance of albums these days for artists and the audiences?"
"Mod was over in the South of England by spring of 1965 and in a sense, the band had changed too," Townshend said. "We were less pure, less an R&B band and becoming more of a singles-oriented pop band. So there is an irony in the fact that when I decided we needed to reconnect with that vitally important and colorful period of our career and our lives as young men trying to pursue a dream of becoming famous and respected, I realized I would need a double album. I'm pleased to hear about artists who uphold the album as an art form."
"The digital medium is only starting to lend itself to (long form) work, so I expect to see more of it," Townshend continued. "It was once thought that new music fans had a low attention span, but what they reveal is immense commitment to researching what touches them most deeply, and as the Internet gets faster they can find what they seek more quickly. Once a connection is made, it can be extremely deep and long-lasting. This is really just another echo: This is how it was back in the '60s: singles first, then albums. Maybe the preponderance of singles on the Internet has made the album feel special again. Maybe the old way of listening to music -- in longer sittings -- is finding its way back into vogue?
When asked what songs from the album are Townshend's favorite to perform live, he said that he enjoys playing all of it, in that it's a unique piece of work. He did share, however, "The real high point for me is always the final song, 'Love Reign O'er Me.' Roger and I now stand almost alone together, representing not only the original band, but also its Mod audience, and of course, all our other early fans. We are connected by it, in what is the most clear-cut prayer for redemption, and it feels like an acknowledgement that rock music has managed to deal with the highest emotional challenge: spiritual desperation."
Granted, when Quadrophenia comes to a close, that's not the end of the show. Townshend and Daltrey return with the band to perform a selection of the band's tunes from other chapters in its history and acknowledge a long and storied career. With the current tour, however, The Who is once again celebrating one of its most classic albums and a brotherhood that, even despite previous rifts, continually binds Townshend and Daltrey together as musical soul mates and icons of rock from another era.
The Who will perform Quadrophenia in full (as well as more hits from the band's career) when it arrives at BOK Center on Thursday, Feb. 14. Tickets are still available and range from $39.50 to $129.50.
Send all comments and feedback regarding Music to firstname.lastname@example.com.
URL for this story: http://www.urbantulsa.comhttp://www.urbantulsa.com/gyrobase/Content?oid=oid%3A56669


text:
Publisher: Victor Gollancz Limited
Publication Date: 1999
Your Satisfaction is Guaranteed:
In 21st century Europe, endlessly ravaged by the changes of war and technology, gene hacker Alex Sharkey is a bare step ahead of the police and the Triads. Sharkey finds himself in more trouble when he helps create a new species.
BookHints: Book Lovers Recommend...
Pasquale's Angel
McAuley, Paul J.
Red Dust
McCauley, Paul R.
Child of the River
McAuley, Paul J.
The Child Garden: Or a Low Comedy
Ryman, Geoff
Eternal Light
McAuley, Paul J.
Shrine of Stars
McAuley, Paul J. |
Fairyland: Search Results
1. |
McAuley, Paul J. Quantity Available: 1
Book Description: Vista, 1996. New Edition. Book Condition: new. 1st edition 1st printing paperback, new In stock shipped from our UK warehouse. Bookseller Inventory # 22180 Bookseller & Payment Information | More Books from this Seller | Ask Bookseller a Question |
Portions of this page may be (c) 2006 Muze Inc. Some database content may also be provided by Baker & Taylor Inc. Copyright 1995-2006 Muze Inc. For personal non-commercial use only. All rights reserved. Content for books is owned by Baker & Taylor, Inc. or its licensors and is subject to copyright and all other protections provided by applicable law.
Portions of this page may be Copyright VNU Entertainment Media (UK) Ltd., 2006, Georg Lingenbrink GmbH & Co., Tite Live, S.A or Informazioni Editoriali S.p.A. All rights reserved.


text:
Login | Not a member? Join now!
Blavatnik Award winning scientist Dr. Jonathan Fisher discusses the power of various visualization techniques in researching—and educating about—the brain.
Author Alan Weisman considers the meaning and means of achieving a sustainable future in this excerpted coverage of a talk he presented at the Academy.
Those who don't know history are doomed to reinvent wheels and miss out on great stories! A historian and a young scientist discuss the rewards and importance of learning about the history of science.
Can science help us understand ethics?
Scientific images are often beautiful, captivating both for their aesthetic value and the concepts they represent.
As part of our Science and the Seven Deadly Sins series, Dr. Paul Zak discusses his work studying the relation of hormones to human behavior. Specifically, his research focuses on oxytocin's role in regulating generosity and greed.
The final installment of our step-by-step analysis of the cheeseburger culminates in a question that's both very simple and tremendously complex—should we eat meat?
In this installment of A Thought for Food's consideration of the cheeseburger, we analyze the king of side dishes, the French fry.
The fourth installment of our systematic breakdown of a cheeseburger deals with ketchup and pickles, two attempts to give vegetables the power to defy time.
For the third installment of our dissection of the humble cheeseburger, A Thought for Food considers a Paleolithic super food that's still popular worldwide—cheese.
Science & the City is the public gateway to the New York Academy of Sciences. We publish a comprehensive calendar of public science events in New York City, host events featuring top scientists in their fields, and produce a weekly podcast covering cutting-edge science.
About | Contact | Feedback | Donate
Become a part of our social networking communities to receive relevant new information and connect with others in your field.
Subscribe to our free weekly e-mail highlighting science events in the New York metro area.
See a sample issue
Oysters are on the front lines of the push to rehabilitate New York Harbor. Learn more about these mighty bivalves from the New York Harbor School.
This video was made in conjunction with The Sackler Institute for Nutrition Science and Science & the City's Can Oysters Save New York Harbor? event held on April 26, 2012. Come back soon for a free public eBriefing of the event.
Academy members get discounts on tickets to all Science & the City events and free admission to 100+ scientific events every year. Your membership also gets you free, unlimited access to our eBriefings, the entire catalogue of the Annals of the New York Academy of Sciences (our scientific journal dating back to 1823), and you'll be making an important contribution to support science in New York and beyond.


text:
Grab a Button!
Product 39/41
Vigorous Negotiations -- Excerpt Chapter One Leah David rested her head against the door. So this is how it ends. The somber thought brought tears to her eyes. Why? Why? Why? A sad sigh passed her lips as she leaned her forehead against the cool wood panel. Why did I stick to my guns during the renegotiations of my Total Power Exchange? A shiver raced down her spine. She couldn't even say the issue was a larger monthly allowance or the size of her wardrobe. No. Isaiah Moore wouldn't have blinked at that request. His wealth was almost as great as his sexual appetite. What had brought the negotiations to a halt was her determination to have him bite her. Have him become her Creator. For the first time since she'd entered his house, he'd been stunned speechless. When he finally did speak to her, he'd railed at her for what he called her mortal misconceptions of what it was like to be a vampire. Truthfully, she had no misconceptions about the vampire lifestyle. She had lived in his house for twelve months—seen all the grotesqueness of what it meant to be a night-walking blood-sucker. Granted, at first the proverbial 'blood feast' had been a stomach-churning experience. The slurping sound and moans of exquisite pain had overwhelmed her, but she realized within the first sixty days of her becoming his submissive that he didn't drink blood every night. Nope. Isaiah only drank when he couldn't stand the intense hunger pangs. And, she reminded herself, he never went any further than his already altered sex slaves. That's where the deal breaker came in, she supposed. His altered slaves never travelled with him when he was called away from his mansion on a business trip. He'd told her it was for the mortal world's protection, because most of his 'creations' didn't have the self-control he did. Once he bit her—game over. His sex kitten was stuck at home because he thought she too would turn into a mindless killer. Nitwit. She'd sooner turn into a werewolf than a blood hungry psychopath. 'You're thinking awfully hard, slave?' his question sounded from directly behind her. Startled, she laid her hand over her clanging heart. 'Forgive me, Master.' Quickly clearing her mind, she bit her lip as she turned to stare at the handsome, four-hundred-year-old vampire she'd fallen in love with. She blinked back the fresh batch of tears stinging the corners of her eyes. 'It's my last night with you.' Quelling the urge to wrap her arms around his broad shoulders and tell him her deepest desires, she bowed her head. Vigorous Negotiations -- Excerpt As was his habit, he brushed his hand over her hair. It was the only outward sign he delivered that showed he gave a good God damn about her. 'Yes, it is,' Isaiah commented. 'And, I intend to make it a night you will never forget.' **End Excerpt**


text:
Very good! Fantastic rates for London. Perfect location, near from Buckinham Palace, kindly staff and razoable confort. Its simple, not luxury, good for easy going people. The bathroom is very very small, but its ok. Really great location and good neighborhood, with great coffee shops.
- Reservation Options:
- TripAdvisor is proud to partner with Expedia, Travelocity, Asiatravel.com Holdings, Hotels.com and Otel so you can book your Eaton House Hotel reservations with confidence. We help millions of travellers each month to find the perfect hotel for both holiday and business trips, always with the best discounts and special offers.


text:
Nutrition basics (20)
- Dietary fiber: Essential for a healthy diet
- Artificial sweeteners and other sugar substitutes
- Added sugar: Don't get sabotaged by sweeteners
- see all in Nutrition basics
Healthy diets (12)
- DASH diet: Tips for dining out
- DASH diet: Tips for shopping and cooking
- DASH diet: Healthy eating to lower your blood pressure
- see all in Healthy diets
Healthy cooking (14)
- Meatless meals: The benefits of eating less meat
- Healthy cooking for 1 or 2
- Beans and other legumes: Types and cooking tips
- see all in Healthy cooking
Healthy menus and shopping strategies (13)
- Free range and other meat and poultry terms
- Cuts of beef: A guide to the leanest selections
- Mayo Clinic Healthy Weight Pyramid: A sample menu
- see all in Healthy menus and shopping strategies
Mediterranean diet recipes
Experiment with eating the Mediterranean way with these healthy recipes.
By Mayo Clinic staffPeople who follow the Mediterranean diet have a longer life expectancy and lower rates of chronic diseases than do other adults. Indeed, the Dietary Guidelines for Americans point to the Mediterranean diet as an example of a healthy-eating plan.
The Mediterranean diet emphasizes plant-based foods, such as fruits and vegetables, whole grains, legumes and nuts. It replaces butter with healthy fats, such as olive oil and canola oil, and uses herbs and spices instead of salt to flavor foods. Red meat is limited to no more than a few times a month, while fish should be on the menu twice a week.
The Mediterranean diet is also about enjoying delicious foods — as you'll discover when you try these recipes.
Main dishes
Salads and sides
Healthy desserts
- Mediterranean Diet & Pyramid: Overview. Oldways Preservation Trust. http://www.oldwayspt.org/resources/heritage-pyramids/mediterranean-pyramid/overview. Accessed Sept. 6, 2012.
- Dietary Guidelines for Americans, 2010. U.S. Department of Health and Human Services. http://www.cnpp.usda.gov/DGAs2010-PolicyDocument.htm. Accessed Sept. 6, 2012.
- Mediterranean diet tips for everyone. Oldways Preservation Trust. http://www.oldwayspt.org/what-can-you-do/consumers?page=5. Accessed Sept. 6, 2012.
Share on: