text:
If you know about Ripper, you know that it's a bridge between the ruby language parser and your own ruby app. It lets you parse ruby files just as ruby would see them. It's currently marked as experimental, but its been in ruby since 1.9.
Ruby 2.1.0 changes of note.
The Ruby 2.1.0
Release is nearly a month old, so its well past time to look over the changes and uncover the features least discussed.
This release received relatively exceptional social coverage. The attention largely due to the addition of Generational Garbage collection. A bit of exploration reveals changes that may have been overlooked in the shadow of RGenGC.
private def
:def now returns a symbol, a clearer return response then the former nil
irb(main):001:0> def hello
irb(main):002:1> end
=> :hello
Coupled with new private and protected methods now take in a symbol:
class Offer
def == other
if self.class == other.class
salary == other.salary
def initialize(compensation)
@compensation = compensation
protected def salary
irb(main):150:0> Offer.protected_instance_methods
=> [:salary]
Required keyword arguments
class Offer
def initialize(compensation:, position: "Engineer")
@position = position
@compensation = compensation
Mark the compensation attribute as required by omitting its default value.
irb(main):170:0> Offer.new(compensation: 70000)
=> #
irb(main):171:0> Offer.new(compensation: 70000, position: "Sales Analyst")
=> #
irb(main):172:0> Offer.new(position: "Sales Analyst")
ArgumentError: missing keyword: compensation
Now we can take any enumerable and derive a hash from it.
(1..10).collect{|a|[a,(a * 2)]}.to_h
Array implements to_h separately
[[:name, :age], ["Matz", 48]].to_h
#to_h is a convenience method that has been a long time coming.
Refinements build a sandboxed around the duck punching / monkey patching of core classes such as numeric.
module CurrencyDecorator
refine Numeric do
def to_currency
s% 0.2f", { :currency => "$", :number => self})
class Currency
using CurrencyDecorator
def initialize(numeric)
@number = numeric.to_f.to_currency
Currency.new returns an implicit conversion of any Numeric param to a decorated stringified float conforming to currency format. All within the safe confines of Currency object.
irb(main):052:0> Currency.new 45.888
<Currency:0x007fd6db0e19b0 @number="$45.89">
irb(main):054:0> Currency.new 79987.87666767
<Currency:0x007fd6db0e19b0 @number="$79987.88">
Numeric outside Currency is unaffected.
irb(main):017:> 748.to_currency
NoMethodError: undefined method `to_currency' for 748:Fixnum
irb(main):018:0> 748.9.to_currency
NoMethodError: undefined method `to_currency' for 748.9:Float
Updates in Std lib
Vector finally implements cross product
Vector[0.6, 0, 0].cross_product Vector[0, 1.4, 0]
Leveraging GMP
The GNU Multiple Precision Arithmetic Library
Large performance increase for calculations involving Bignums
Bignum and Fixnum respond to bit_length
human_population = 10900000000
=> 34
(human_population * human_population).bit_length
=> 67
Thats the quick tour of the less hyped changes
Next I'll be running through Ruby Koans to explore behavioral differeinces
Visualizing Garbage Collection by Pat Shaughnessy
Visualizing Garbage Collection in Rubinius, JRuby and Ruby 2.0
In this talk we'll dive into Ruby internals and take a close look at an ugly topic: garbage collection. How do these Ruby VM's allocate memory for new objects? How do they identify unused objects? How do they reclaim memory from garbage objects, allowing it to be used again?
You can learn a lot about someone from their garbage. Using a series of diagrams, we'll visually compare and contrast the complex algorithms these very different Ruby implementations use. What computer science research is behind each garbage collector? We'll also look at the GC changes planned for the upcoming Ruby 2.1 release.
Pat Shaughnessy is a Ruby developer working at McKinsey & Co., a global management consulting firm. Author of Ruby Under a Microscope, Pat loves diving into the details of a technology, learning how it works, and then explaining it in simple terms that everyone can understand. Pat's blog articles and conference presentations have been featured multiple times on the Ruby Weekly newsletter, the Ruby5 podcast and the Ruby Show.
Messages Not Types: Exploring Ruby's Conversion Protocols
Duck typing is a style of programming that relies on what an object does, rather than on what it is. Avoiding class dependencies results in highly flexible code. Ruby's conversion protocols, used throughout the core and standard libraries, are a great example of the power of duck typing. In this post, we'll look at two of Ruby's conversion protocols: loose and strict.
Using Ruby Expect Library to Reboot Ruckus Wireless Access Points via ssh
We require a nightly rebooting of our Ruckus Wireless WiFi access points. The Ruckus controllers (ZoneDirector™ and FlexMaster™) do not offer that capability [automated reboots] via their web interface. This blog posts describes a method of using the ruby expect library, ssh, cron, Ruckus's CLI, and a ruby script to reboot the APs.
Create A Less-privileged User
We need to create a less-privileged (i.e. not a "Super Admin" user). You can probably guess where this is heading: we're going to need to keep a plaintext copy of this user's password on disk. Sure, we're going to do our best job to lock down the file so no one can read it, but we need to plan for the worst: we need to minimize the amount of damage that can be done in the event the account is compromised.
- log into the web interface of the ZoneDirector (e.g. https://zone-director.pivotallabs.com)
- Configure → Roles → Create new
Name: ruckus_reboot
Description: For automated rebooting of the Ruckus APs
Administration: checked: Allow ZoneDirector Administration
selected: Operator Admin (Change settings affecting single AP's only)
- Click OK
- Configure → Users → Create new
- User Name: ruckus_reboot
Full Name: Reboot APs
Password: Iluvmuhdawg! (use a different password; this one is an example)
Confirm Password: Iluvmuhdawg!
Role: ruckus_reboot
- Click OK
Put ruckus_reboot's password in a safe place
We copy the password into a file that can only be read by the root user. Remember to substitute the password you originally created for the ruckus_reboot user:
echo 'Iluvmuhdawg!' | sudo tee ~root/.ruckus_reboot_passwd.txt
sudo chmod 400 ~root/.ruckus_reboot_passwd.txt
The Manual Procedure
We use the newly-created user to ssh into the ZoneDirector and reboot the APs. First, we log into the ZoneDirector to find out the MAC address of the AP we want to reboot:
$ ssh zone-director.pivotallabs.com
Please login: ruckus_reboot
Welcome to the Ruckus Wireless ZoneDirector 1100 Command Line Interface
ruckus> enable
ruckus# show ap all
MAC Address= 50:a7:33:22:99:b0
Model= zf7962
Secondly, we use the MAC address of the WiFi AP (i.e. "50:a7:33:22:99:b0″) to tell the ZoneDirector to reboot that particular AP:
ruckus# debug
ruckus(debug)# restart-ap 50:a7:33:22:99:b0
The command was executed successfully.
ruckus(debug)# quit
No changes have been saved.
ruckus# exit
Exit Ruckus CLI.
Connection to ruckus-mgt closed.
The Automated Procedure (the Code)
We write a ruby script to automate the manual procedure. There are two aspects: first, we compile a list of the MAC addresses of the WiFi APs we want to reboot; secondly, we reboot the APs. The first is accomplished by using the
show ap all command and parsing it for the MAC addresses, and the second is accomplished by looping through the list of MAC addresses and sending the
restart-ap command. Copy the following script into a file named
#!/usr/bin/env ruby
# ap-reboot.rb ruckus-zone-director ruckus-admin-account
# EXAMPLE: ap-reboot.rb zone-director.pivotallabs.com ruckus_reboot < ~root/.ruckus_reboot_passwd.txt
# This script remotely logs into a Ruckus Zone Director and reboots the APs
require 'pty'
require 'expect'
raise "#{__FILE__.gsub(/.*\//, '')} ruckus-zone-director ruckus-admin-account" if ARGV.length != 2
password = STDIN.gets.chop
aps = []
def harvest_mac_addrs(buffers)
aps = []
buffers.each do |buffer|
buffer.lines do |line|
next if !line.match(/MAC Address/)
# chop chop for '\r' '\n'
mac_addr = line.chop.chop.gsub(/.*MAC Address= /, '')
aps << mac_addr
PTY.spawn("ssh", ARGV[0]) do |ssh_out, ssh_in, pid|
ssh_out.expect(/ease login: /) { |r| ssh_in.printf("#{ARGV[1]}\n") }
ssh_out.expect(/assword: /) { |r| ssh_in.printf("#{password}\n") }
ssh_out.expect(/uckus> /) { |r| ssh_in.printf("enable\n") }
ssh_out.expect(/uckus# /) { |r| ssh_in.printf("show ap all\n") }
ssh_out.expect(/uckus# /) do |r|
aps = harvest_mac_addrs(r)
aps.each do |ap|
ssh_out.expect(/uckus\(debug\)# /) do |r|
ssh_in.printf("restart-ap #{ap}\n")
ssh_out.expect(/uckus\(debug\)# /) { |r| ssh_in.printf("quit\n") }
ssh_out.expect(/uckus# /) { |r| ssh_in.printf("exit\n") }
Copy the script into place
$ sudo chmod 755 ap-reboot.rb
$ sudo cp -i ap-reboot.rb /usr/local/sbin/
Test the script
- Log into the ZoneDirector's web interface (e.g. https://zone-director.pivotallabs.com).
- Monitor → Access Points
In a terminal, type the following:
sudo ssh zone-director.pivotallabs.com
Reply "yes" if you're asked if you still want to connect even though the authenticity "can't be established". This step is merely to populate the ssh key; you don't need to log in. Hit Ctrl-C if you're presented with the "Please login:" prompt.
sudo cat ~root/.ruckus_reboot_passwd.txt | sudo /usr/local/sbin/ap-reboot.rb zone-director.pivotallabs.com ruckus_reboot
The length of time the script takes to finish executing is approximately 2.5 minutes/AP. It requires ~30 seconds per AP for setup, and it waits 120 seconds between each AP reboot.
From your browser, you can watch the APs rebooting (i.e. An AP's status will change to "Disconnected" when it's rebooting).
Add the script to the crontab
We decide to reboot the APs beginning at 54 minutes past midnight. We add the line to /etc/crontab on an Apple OS X 10.6 machine. Note that the existence of the /etc/crontab file is distribution-dependent: The file does not exist on later versions of OS X but does exist on FreeBSD 9.1 and Ubuntu 13.04.
$ sudo vim /etc/crontab
54 0 * * * root /usr/local/sbin/ap-reboot.rb zone-director.pivotallabs.com ruckus_reboot < ~root/.ruckus_reboot_passwd.txt > /dev/null 2>&1
What to expect from the Ruby expect library? is an excellent primer.
Pivots Talking Tuesday: Arduino the Ruby way
This week on Pivots Talking Tuesday, I present to you Austin Vance speaking on using Ruby with Arduinos at Ruby Conf 2012. If you're wondering what the thing is he's standing next to, it's a Ruby and Arduino powered tshirt cannon… and yes he fires it during his talk.
What's the deal
Writing software is great, websites, applications, and scripts are things we interact with every day. What about writing software that we can interact with in the physical world? From automated sprinkler systems that turn off when you pull into your drive way, to scoreboards at the company foosball table physical computing opens a door for the innovator inside every software engineer.
It's too hard
Not true, there are amazing libraries and compilers that let us write software for Arduinos in the best language, Ruby. Think about it no C, no headers, and no static types, just plain old ruby. That is a good deal.
In this talk I will go over a few of the most popular Ruby libraries for interacting with an Arduino, talk about some basics of each library and then spend time on how these libraries and Arduino can interact to create applications that respond in the physical world. There will be t-shirts shot from a robotic cannon.
ActiveRecord Refactoring: Move Association Behavior to Associated Class
In a typical Rails app, one ActiveRecord model tends to accumulate a lot of associations and related methods. This is usually the
User class; e.g., the
User has many posts, comments, contacts, projects, etc. It's also common to have a few instance methods to filter these associations, e.g.,
User#unpublished_posts, or
Soon this God class becomes overwhelmed by all of these responsibilities. The intent of this refactoring is to move this behavior to the associated class.
Knowing Too Much
The following ActiveRecord model has a few associations (to keep this example simple), and an instance method to filter one of them.
class User < ActiveRecord::Base
belongs_to :account
has_many :projects
has_many :contacts
def active_projects
projects.where(active: true)
User#active_projects seems to know too much about the domain's concept of an active project. Let's move it to the
Project class.
Moving Responsibilities
User#active_projects can be converted to a class method on
class Project < ActiveRecord::Base
def self.active_projects_for(user_id)
where(user_id: user_id)
.where(active: true)
We now need to update senders, e.g.,
ProjectsController#index, to use this new class method.
class ProjectsController < ActionController::Base
def index
@projects = current_user.active_projects
class ProjectsController < ActionController::Base
def index
@projects = Project.active_projects_for(current_user.id)
Responsibilities in Their Right Place
We can now remove the
projects association and related instance method from
User becomes simpler, and responsibilities feel like they're in their right place.
Replace Class Query Method with Query Object
If the associated class starts to accumulate too much behavior, or we just don't like class methods, then we could introduce a query object.
class ActiveProjectsQuery
def initialize(relation = Project.scoped)
@relation = relation
def for(user_id)
.where(user_id: user_id)
.where(active: true)
Question Bidirectional Associations
When a new feature requires an ActiveRecord association, avoid the tendency to automatically make it bidirectional. Bidirectional associations often result in too many parent class responsibilities. Instead, implement these responsibilities in the associated class. It's more work, but your classes will stay small, cohesive, and ungodlike.
Reading the Ruby Source to Understand Rails Idiosyncrasies
Suppose somewhere within our Rails application, we have something like the following line of code.
(10.days.ago..2.days.ago).include? Date.today
The formulation represents the power of Ruby and the expressiveness of Rails. All seems fine and well. That is, until the code is executed. Suddenly, our snappy application grounds to a halt and our server log spits out a single warning over and over creating a wall of text, as if we have entered an infinite loop. The source of the warning comes from deep within ActiveSupport:
activesupport/lib/active_support/time_with_zone.rb:364: warning: Time#succ is obsolete; use time + 1
Totally confused as to why our seemingly idiomatic Rails code breaks, we ask a helpful colleague who promptly tells us, "Oh, just use the 'cover' method instead of 'include' on that range and you'll be fine." So we switch method calls and test the following code in the Rails console:
(10.days.ago..2.days.ago).cover? Date.today
Without a hiccup, the method blithely and immediately returns
So what happened there? We might dig around ActiveSupport::TimeWithZone — the class of objects like
10.days.ago — but we won't discover the root of the problem unless we go straight to the Ruby source and look at how
Range#include? and
Range#cover? differ.
To start, we need to look at range.c, the file where the behavior of our favorite Ruby class is defined. It's in the function
Init_Range all the way down on line 1314 where the magic happens.
Init_Range(void) // line 1314
// ...
rb_define_method(rb_cRange, "include?", range_include, 1); // line 1355
rb_define_method(rb_cRange, "cover?", range_cover, 1); // line 1356
Init_Range, all the various methods on the Range class (e.g.,
#first, etc.) are hooked up to C functions. For our purposes, line 1355 and the following line are the most important. On those lines, we have calls to
rb_define_method which takes a defined class, a method name, as well as a pointer to an actual C function which does all the work. The final argument defines the arity of the method.
So basically, we need to understand the difference between
range_cover (defined here) and
range_include (defined here).
To start, let's take a look at the simpler (and shorter) of the two:
static VALUE
range_cover(VALUE range, VALUE val)
VALUE beg, end;
beg = RANGE_BEG(range);
end = RANGE_END(range);
if (r_le(beg, val)) {
if (EXCL(range)) {
if (r_lt(val, end))
return Qtrue;
else {
if (r_le(val, end))
return Qtrue;
return Qfalse;
The function begins by looking up the beginning and ending values of the range by using the macros
RANGE_BEG and
RANGE_END, both of which are defined at the file's head. Typically, macros in the Ruby source are denoted by all caps and often can be found in the same file.
Next, the function asks if the range's beginning value is less than or equal to (i.e.,
r_le, "range less than or equal to") the value in question. If that test succeeds and we enter the if-branch, the function then asks if the range is an exclusive range (e.g.,
1..10 which includes 10 vs.
1...10 which does not). The exclusive range test (i.e.,
EXCL) is yet another macro.
If we do have an exclusive range, then the next question is to ask if our value is less than (i.e.,
r_lt, "range less than") the end value. If that's true, we're done and we return
Qtrue, the Ruby wrapper for a truthy boolean value. If we do not have an exclusive range, we ask instead if our value is less than or equal to (again with
r_le) the end of the range, again returning
Qtrue if the test is successful. Finally, if we haven't already returned
Qtrue, we know to return
Now with an understanding of what
Range#cover? is doing under the hood, it's easy to see why it's quick to return. In effect,
Range#cover? is simply comparing the beginning and ending points of our range with the passed-in value. It's fast, it works, and doesn't spend any time iterating through the inclusive values.
Range#cover? gets the job done, what's
Range#include? doing so differently?
A quick scan of
range_include reveals an interesting twist: the function contains the entirety of
static VALUE
range_include(VALUE range, VALUE val)
// ... lines 1141-1149
if (r_le(beg, val)) {
if (EXCL(range)) {
if (r_lt(val, end))
return Qtrue;
else {
if (r_le(val, end))
return Qtrue;
return Qfalse;
// ... lines 1161-1182
Incidentally, an early implementation of
Range#include? written by Matz was practically identical to the current implementation of
Range#cover?. So what is
Range#include? doing that causes the endless warning messages about
Time#succ being obsolete?
range_include is twice as long as
range_cover, let's break the function up into parts and look at it piece by piece.
To start, we have some setup:
static VALUE
range_include(VALUE range, VALUE val)
VALUE beg = RANGE_BEG(range);
VALUE end = RANGE_END(range);
int nv = FIXNUM_P(beg) || FIXNUM_P(end) ||
rb_obj_is_kind_of(beg, rb_cNumeric) ||
rb_obj_is_kind_of(end, rb_cNumeric);
// ... lines 1147-1182
range_cover, we start by looking up the beginning and ending values of our range. We also assign an
int variable to tell us if we have a numeric value (hence the name "nv"). The variable
nv will be truthy (i.e., non-zero in C) if at least one of four conditions is met: 1) we have a pointer to a Fixnum (checked by the macro
FIXNUM_P) for the beginning value, 2) a Fixnum pointer for an ending value, 3) our beginning value is a kind of Numeric class, or 4) our ending value is a kind of Numeric class.
Next we test to see if we can use our
range_cover logic.
static VALUE
range_include(VALUE range, VALUE val)
// ...
if (nv ||
!NIL_P(rb_check_to_integer(beg, "to_int")) ||
!NIL_P(rb_check_to_integer(end, "to_int"))) {
// execute range_cover logic
// ... lines 1162-1182
Aside from checking if we have a numeric value (as defined above), we also check to see if we can convert the
beg or
end variable with the
to_int Ruby method. If one of our three tests succeeds, we execute the
range_cover algorithm. In Ruby land, this code covers the case for ranges like
(1..10) (Note that we're overlooking the cases when
to_int returns a numeric value). Clearly, we have not found the source of the warning message yet.
At this point, we have two suspects to check for our endless warning messages: 1) an
else branch which follows from the
if branch above and 2) a call to super, i.e.,
rb_call_super, all the way at the end of
range_include. Let's start with the
else branch.
static VALUE
range_include(VALUE range, VALUE val)
// ... lines 1141-1161
else if (RB_TYPE_P(beg, T_STRING) && RB_TYPE_P(end, T_STRING) &&
RSTRING_LEN(beg) == 1 && RSTRING_LEN(end) == 1) {
if (NIL_P(val)) return Qfalse;
if (RB_TYPE_P(val, T_STRING)) {
if (RSTRING_LEN(val) == 0 || RSTRING_LEN(val) > 1)
return Qfalse;
else {
char b = RSTRING_PTR(beg)[0];
char e = RSTRING_PTR(end)[0];
char v = RSTRING_PTR(val)[0];
if (ISASCII(b) && ISASCII(e) && ISASCII(v)) {
if (b <= v && v < e) return Qtrue;
if (!EXCL(range) && v == e) return Qtrue;
return Qfalse;
/* TODO: ruby_frame->this_func = rb_intern("include?"); */
return rb_call_super(1, &val);
In the
else branch, we immediately have another
if. We first test to see if our
beg and
end variables are pointers to a string type with the
RB_TYPE_P macro. If those two conditions are met, and the length of each variable is 1 (checked by using another macro,
RSTRING_LEN), we proceed. In Ruby land, this code is testing for a range like
If our
val variable is also a string type and its length is either zero or greater than one, we can immediately return
Qfalse. Otherwise, we use another macro,
RSTRING_PTR, and an array lookup on the returned C string, to store copies of the beginning, ending, and tested value. From there, we simply have to check that each
char is in fact an ASCII character, in which case we can compare their numerical values, much in the same way as we did with
Having eliminated all but one possible suspect, we now know that our warning messages are triggered by something beyond
range_include in the superclass of Range. For those well acquainted with Range and its ancestors, we have a clear culprit: Enumerable.
Rather than dive deeper into the source, let's return to Ruby land and test our hypothesis with a monkey patch.
class Range
alias_method :old_each, :each
def each
puts "Calling each..."
By rerouting the
each method through our own version of the method, we can see if the original line from above is in fact hitting the
each method. So we type the line in again and hit enter.
(10.days.ago..2.days.ago).include? Date.today
Now in place of our wall of warnings, we see our own message repeated until Ruby throws a
SystemStackError. Progress!
Rather than an infinite loop, it looks like we're trying to iterate over all the intervals within our time range. Let's test that (with a fresh instance of the Rails console to clear out our monkey patch):
(3.seconds.ago..2.seconds.ago).include? Date.today
With only two seconds to test, in place of a wall of text, we have only two error messages and then the correct return value. So the root problem is not that an infinite loop is present inside Ruby or Rails (of course!), but rather that our
range_include is built to handle ranges like
("ant".."any") by delegating to Enumerable to test all possible intermediate values (i.e., "anu", "anv", "anw").
So what's to be done? Take the helpful colleague's advice and use
Range#cover? instead.
Ruby/rails performance tools
You have a rails webapp, you're doing TDD, you are always implementing the simplest thing that could possibly work. Well guess what, the simplest is not always the most performant.
If you are always doing simplest thing you'll not likely to face performance issues early in the product especially if it's a new product and you won't have lots of users nor data. But the time will come that your simplest thing will bite you, and that's fine, if you know what to do.
Finding some performance holes can be quite easy if you have the right tools, some problems are straightforward and often times solving the simple problems will be more than enough. The bullet gem is a great starting point to find N+1 queries, unecessary eager loading and opportunity to use counter cache.
A classic example of the N+1 queries problem: you have a model with a relation, you're listing all the records for this model with their children below it. For instance:
<% @articles.each do |article| %>
<h2><%= article.title %> comments:</h2>
<%= article.comments.each do |comment| %>
<li><%= comment.content %></li>
<% end %>
<% end %>
Bullet will give you the recommendation for this one:
N+1 Query detected
Article => [:comments]
Add to your finder: :include => [:comments]
But what if it's not something that bullet can pickup? Well I personally like rack-mini-profiler. MiniProfiler will profile your code and report it in a very nice way right on your page.
You can then drill down to where are all the queries being generated. Say you have something like this:
Total Upvotes: <%= @comments.sum(&:upvotes) %>
<% @comments.find_each do |comment| %>
<%= comment.content %>
<% end %>
You'll see a slow portion but not a lot of extra queries, that's because we're using find_each here to paginate the load of the comments, and the first line we're calling
sum(&block). This is causing ActiveRecord to load all of the comments in memory to calculate the sum.
To fix this you just have to use the active_record's version of sum by removing the ampersand, that is assuming
@comments is an
ActiveRecord::Relation. This will issue a database SUM and will avoid loading all the comments in memory, it is not only faster but also more memory efficient. See how the sum query is considerably faster than the
SELECT * one:
Total Upvotes: <%= @comments.sum(:upvotes) %>
# ...
ActiveRecord has a lot more to offer, try to use database calculations when it makes sense.
MiniProfiler also has other nice features, to learn more about it I highly recommend checking out this screencast.
You can also go further down the hole and use the ruby-prof gem. If it's the case where your bottleneck is not the database or if you're not on a rack application where you can use the MiniProfiler. To use ruby-prof first you have to install it (of course), then you need to call to the ruby-prof API for it to profile your code.
You can either profile entire requests by using their middleware (add this to config.ru):
use Rack::RubyProf, path: 'tmp/profile'
Another way to run the profiler (and this one works even outside of rack applications is by manually calling the API within the code. ruby-prof's README explains how to do that but it basically consists of starting and stopping the profiler:
result = RubyProf.profile do
# ... code to profile ...
printer = RubyProf::MultiPrinter.new(result)
printer.print(path: 'tmp/profile', profile: 'my-profile')
Both will create a few files under your tmp/profile directory. I found the html versions easier to parse visually. You'll find a call stack and a graph report, they are both a bit difficult to understand but once you do they help you quite a lot on figuring out where the problem is, it's a bit out of the scope of this blog post to explain all that output, I got some insight from this paid screencast.
These three tools will be extremely helpful to you if you learn them. Always be monitoring your app's performance with some tool like New Relic, don't wait until you lose all your users because you app is too slow. It is unlikely that you'll find all the problems yourself and the tools I mentioned will only help you solve problems you know about.
Geek glossary: stub
Over the next few blog posts I intend to bang a few more nails in the coffin of the widespread misunderstanding of stubs, mocks and spies. Many before me have had a crack at this (see Ben Moss's post for discussion and links), and many of those blog posts and books helped me to understand what exactly these code design tools are for. I'm still no expert, but I do think about the application of these tools with unhealthy frequency.
I intend to focus primarily on the usage of these terms inside the Ruby ecosystem, but these definitions also apply to other languages.
Let's start with stubs. They're a useful TDD and design tool. They are not mocks, and they arguably precede mocks in the history of TDD tooling. Like most terms surrounded in confusion, there are a few applications of the same idea:
- Pure stub objects
- Partial stub objects
- Stub methods
- Stub protocols
- Stub services
In general, however, a stub is a simplistic implementation of a role that is played in a system. The purpose of a stub is to guide execution down a particular path, usually to verify that another, unstubbed part of the system is doing its job properly.
Pure stub objects
Perhaps most commonly, stubs are used in a unit test to replace collaborators of the system under test. They allow the tester to avoid exercising code that belongs to other units. By replacing these collaborators, they give the test writer control over the indirect inputs to the system under test.
This sort of language mangling deserves an example. Let's say we have two objects in the system with the same interface. They're swapped out in production code depending on whether the user wants a cached or uncached URL fetch.
- URLFetcher
- #fetch
- CachingURLFetcher
- #fetch
Now, we are testing a user interface that lets someone click on buttons that perform the above actions. We have an example in RSpec that involves user error:
it "displays an error when the fetcher decides an invalid URL has been entered" do
fetcher = double('fetcher')
ui = UserInterface.new(fetcher)
expect(ui).to display_error('You entered a bad URL!')
Note how we're explicitly describing behaviour up to a boundary: this test doesn't care how the stub object raises the exception. Note also how we haven't stubbed any existing methods on existing classes. This is deliberate: it drives out polymorphism in the design. The UI object can use any fetcher that responds to the #fetch message. We should not need to change this test or the UI implementation when we make a change to what constitutes an invalid URL. We are free to construct the UI with different objects and we should expect it to work providing its fetcher collaborator does its job.
We can also say that using a pure stub object helps us to drive composability into our application. If we have proved that one object can work with any object that implements an interface, we have a clear contract that a new implementation needs to fulfil in order to work correctly with that object.
In some languages these contracts are explicit. Java has interfaces and Objective-C has protocols. In Ruby, interface contracts are implicit. If you feel the need to enforce a contract, they can be tested with shared examples.
Partial stub objects
Partial stub objects are concrete objects that have had some of their implementation changed. These are popular with Rubyists who believe you shouldn't need to change your design when a test barks at you. I'm not one of those people. However, in some situations it makes sense to stub methods on existing objects, notably when working with existing code that wasn't designed for polymorphism, or to be composable. Rails, in particular, makes using pure stub objects quite difficult in several places.
Stub methods
We stubbed a method in our example above. When we stub an existing method on an object to make a partial stub object, we are 'stubbing out' a method. This particular verb form of stub leads many to believe that stubbing is only applicable to existing objects. In turn, this leads to some wild arguments that stubbing is bad practice.
With RSpec's stubs, it's important to understand the difference between Example#stub (now deprecated in favour of Example#double) and Object#stub. The former creates a pure test double (which can be a pure stub object), and the latter stubs a method on an existing object (whether it exists or not). Compare:
double('payment gateway')
PaymentGateway.stub(:process_card) { true }
The former returns a new, 'empty' stub object that will explode if any message is called on it. This is an advantage: we usually want a whitelist of messages that are allowed to be called on an object in a particular test example. Whitelisting messages forces our tests to expose the messages of our domain in the tests, which enhances readability and brings complexity to the foreground when it arises.
The latter couples the test to the concrete implementation, 'PaymentGateway', as well as to the message. In general, it's best to reduce coupling of type. This isn't always a problem, though, and many Rails apps in particular have test suites that are opinionated about type. See Jim Weirich's talks on connascence for a detailed treatment of the various levels of sin associated with coupling. See POODR for a translation into Ruby.
Stub protocols
I've included this section to talk about libraries like WebMock. WebMock
is used primarily, despite the confusing name, to stub out low-level network layers. This allows the programmer to pretend an HTTP request responded in a certain way, timed out or failed in some way. It can also be used to 'catch' any stray code that the programmer didn't expect to be calling out to the network.
Whilst WebMock is technically implemented as a bunch of partial stubs, its use tends not to suffer the downsides of partial stubs listed above, because the interfaces it stubs are stable and widely used. Further, because WebMock is so popular, it's likely to be updated when changes to the Ruby built-ins it stubs change.
I tend to use WebMock in high-level acceptance tests when I don't want to call external services. I want to know that the whole of my application's stack was exercised, but don't particularly care whether a real network request was made and completed successfully.
Stub services
Finally, let's look at stub services. These are wildly different to the rest of the stub types described, in that they are simplistic implementations of whole applications that serve some purpose in a system. They may talk HTTP to other services, but will often have a developer- or product manager-facing user interface that allows them to be configured to respond in particular ways.
Using stub services allows one system to be tested in isolation from potentially unreliable external systems. For example, it is tricky to reproduce a time out error occurring in an external system if you have no control over that system. But if you can configure the system you are verifying to instead talk to a replacement service that you do have control over, you can easily reproduce different situations that you need to accommodate in your application.
XP on Ruby Rogues
I had the pleasure of appearing on the Ruby Rogues podcast this week talking about how Pivotal Labs does Extreme Programing (XP). Accompanying me was ex-pivot Josh Susser, James Edward Gray, Avdi Grimm, and Charles Max Wood. I had more fun recording it than I would have imagined and the pivots here have enjoyed listening to it, I hope you will too!
The passing of time, and all of its crimes.
Programmers are constantly implementing time-related features, and accidentally including time-related bugs. I'm one of those programmers, and I would like to reduce the number of time-related bugs that I write. Some of them are small mistakes: time zone issues arise when running a test suite on a machine in a different time zone. These bugs are often fixed with consistent use of the time zone feature of a given time library. Others are more sinister, and lurk deep within the design of a system. They manifest in places where it's tricky to get the system into a certain state because it is so heavily dependent on the current time. I propose that designing for the ability to set the current time from the outside of the system reduces the prevalence of timing related bugs, and has the happy accident of making code more reusable and testable.
How testing exposes this problem
Testing has many forms in the world of software. There are automated acceptance tests, unit tests, functional tests, enemy tests and so on. There are also tests carried out by humans. Sometimes referred to as 'click testing' or Quality Assurance, this kind of testing is an essential part of the process of delivering working software. At Pivotal Labs, it's usually the Product Manager who has the final say about whether a feature is complete, or a bug is fixed. In order to evaluate whether a feature is ready, the PM exercises the area of the application in question, using the interface that a customer or stakeholder has been provided with.
When testing software with a mouse and keyboard becomes difficult, however, it often doesn't get done. When it doesn't get done, bugs introduced by diligent programmers, who test-drive their code, are missed and end up making their way into production.
After a few cycles of missing bugs like this, a team will look for ways to ease the pain of click testing their app. The programmers on the team might come up with clever, easy-to-implement solutions to this problem:
- "We can manipulate the Time library to give us the time we want"
- "We can change all of the data for a given account to pretend that it was created in the past"
When these sorts of techniques dig in, new problems arise. In the former case, you can end up with code that works when the fake Time library is used, but not when the real one is used. In the latter, you are committed to a maintenance chore: when a timestamp field is added, it needs to change along with the rest, and when the code that changes those fields gets out of sync with how things really change over time, more bugs arise. It becomes difficult to tell which bugs are genuine and which are a consequence of artificially shifting time data.
It's usually programmers who propose the above solutions. We often think in low-level terms like libraries and direct data manipulation. From a Product Manager's perspective, however, what's really needed is a design change. One could imagine the user story presented to the team like this:
As a Product Manager
I want to travel in time
So that I can test, for example, that an account gets billed each month
Time travel sounds like science fiction. How could a user of your system possibly travel in time? It turns out that there are low-level solutions to this. For example, Timecop, which many of us at Pivotal have contributed to. If depending on the passing of time is your addiction, then Timecop is enabling you. It lets you easily manipulate time, usually for automated testing purposes. For example:
Timecop.freeze(1.month.from_now) do
future_time = Time.now
sleep 10
future_time == Time.now # this is true
Here we've frozen time to pretend that it's one month in the future. I can imagine some cases where this would be useful (not least in existing systems that are infected with code coupled to the current time), but in a lot of cases this is just wrong. Under what circumstance do you actually expect your code to be frozen in time? What are the consequences of testing code under these conditions?
Perhaps most importantly to the topic of this post, Timecop lets you forget about managing time at the unit level, and doesn't encourage you to build time controls into your application.
I think there are better ways to get a grip on time that we should all consider before reaching for the magic wand. Let's look at some real-world problems that can occur and then look at ways of building time control into an app's design.
Examining the moment
Let's think about the properties of the current time:
- There is only one current time, unless you're modelling multiple realities e.g. storylines about time travel.
- Its value is always changing.
- Everything is potentially affected by it.
So, the current time is a global, constantly mutating singleton. We know that the presence of global singletons is undesirable, because they are polluting. We also know that mutation ought to be contained, because mutable state makes our programs less predictable and harder to reason about. If a function deals with mutable state, then it might have different results each time it is called, even when it apparently has the same inputs.
Let's look at a timing bug that can result from the fact that the current time has these undesirable properties:
policy = Policy.find(1)
if policy.current_state == :active
notify_customer("You are still insured!")
# more code goes here
if policy.current_state == :inactive
notify_customer("You are not insured. Hope you weren't planning on driving anywhere today.")
Imagine that the above code is within a web request. The request comes in at a certain time, and the customer wants to know whether their insurance policy is current. The code above is deep in the guts of a model somewhere, and gets called after the customer has been authenticated, their request has been authorized, and their account record has been pulled out of the database. Now it's time to see what the state of the policy is, so we use a method someone wrote (current_state) that fetches the current time and returns a state based on whether the policy's end date was before or after that time.
The customer sees this on their screen:
You are still insured! You are not insured. Hope you weren't planning on driving anywhere today.
The policy could potentially be active on one line and inactive the next. This kind of bug gets worse when one line makes an external call if the object were in one state, and the next makes a conflicting call if it were in another.
I recently ran into a real bug similar to this on my current project, which was caught when an acceptance test I was writing would fail on one run and pass on the next. The temporary workaround was to memoize the method that checked the current state (current_state above). Unfortunately, this introduced even more mutable state, because memoization requires changing the state of an instance variable. The next programmer might wonder why fetching the current state works the first time he asks, but stays the same with consecutive calls.
The current_state method is guilty here. But what of? It has a hidden input, which is the current time. It's not explicit, and that's where the confusion lies. It wouldn't make sense to have a method called current_something and have it take the time as an argument, because the prefix "current_" implies that it's supposed to know what the current state is.
The internal functions of a program shouldn't know this stuff. In most web apps, a request is made at a certain point in time, but it's not important that the request takes some time. With most scheduled jobs, the job is run at a certain time, but it's not important that the job takes some time (or if it is, it's stored as metadata).
A name less prone to attracting this kind of bug might be state_as_of(time). If we force ourselves to pass the time as a parameter to all of our low-level functions, then we can:
- More easily unit test the basic correctness of the method without resorting to stubbing out the time with Timecop.
- Force out a decision to be made about what moment the lower-level methods should be operating on. Ideally the control would move as high as possible: to the controller level, or in the case of jobs, to the job itself, or to an environment variable.
A word about scheduling
Scheduled jobs are often concerned with when they think they're being run, but a PM doesn't want to wait for a month to see if, for example, the billing system is working. It's important to give control over when a job thinks it's being run to the PM or other person evaluating whether a system works. This might mean dropping your out-of-the-box scheduling interface for the purposes of feature acceptance.
Resque-scheduler has become very popular amongst developers as it's easy to install and provides a cron-like syntax for declaring when jobs are run. It also provides a GUI for triggering scheduled jobs immediately. Unfortunately, there's no way to set parameters for the jobs, so the time can't be set. If you choose to heed the advice in this post and parameterize time, you'll need to provide your own interface for passing the current time into the system. This is a good idea anyway. See GOOS for a good treatment of externalizing event sources, which goes even further than the suggestions in this post in many ways.
Making time a parameter to your jobs can often make the jobs more reusable. For example, I might want to invalidate all sessions in a particular time range because there was a system fault at those times.
A word about external dependencies
What happens if your external dependencies are dependent on the current time? Well, you're going to have problems with that no matter how much control you build into your system. I would argue that the services should be wrapped, and the wrappers should allow the time to be passed in to fake responses if necessary. The acceptance (as in story acceptance in Pivotal Tracker) of your system doesn't have to depend on the state of the other systems.
A word about customer-facing status pages
What if your customer needs to be shown what's happening right now?
I think the trick here is to depend on the order of time, and not the passing of time. To move into the future, we should be reacting to events by adding data, not mutating it. A database can easily figure out what the latest order is, or what the latest billing cycle is. It doesn't have to be a function of the current time.
If, however, it's just too difficult to implement the functionality without checking the current time, it could be argued that the current time be a parameter passed in through the browser, available only in certain testing environments. I would resist this as far as possible, but think that it would be a preferable solution to mutating the state of the database.
Everything I know about Clojure after one week
This week I decided to clear out the cobwebs of my Ruby-trained brain and try a completely different language. Ruby and Rails have been my staples for over seven years, and I'm starting to tire of my patterns of thinking, and of the common problems found in large Rails applications. Specifically, I'm pretty bored of running into slow test suites and difficult-to-maintain apps. I suspect the primary cause of these problems is the entanglement of business logic with database and other stateful resource code. I get the feeling that it can't be just coincidence that so many teams of competent developers fall into the same old traps.
I'd heard a bit about Clojure, so decided to explore the ecosystem and community. I'm attracted to the idea of learning a functional language, avoiding mutable state and re-evaluating the object oriented programming paradigm. Functional programmers are often accused of being "idealistic", "academic" or a variety of other thinly-veiled primitive insults. If nothing else, I could learn to sympathise with these crackpot underdogs who claim to have the cure for most of the technical pain I suffer in my chosen occupation.
Hopefully this assortment of links and lessons learned will encourage you to try out the language, or inspire you to try something else that's refreshingly new.
Clojure is easy to get started with
There are various tutorials online. However, they can be a little out of date. The quickest route to Clojure hacking is via leiningen, a sort of rake-meets-bundler utility. Assuming you're on a Mac, have homebrew installed, a recent JDK and the usual code compilation dependencies:
brew install leiningen
lein repl
That'll pull in Clojure for you. Once you've had a play in the REPL, use leiningen to generate an app:
lein new my-test-project
The project.clj that the above command generates is the equivalent of a gemspec, and declares the dependencies of your app. Leiningen helpfully fetches dependencies lazily when you start a repl, server or run tests. No bundle install step!
Homebrew can also install Clojure for you, but this version will be independent of leiningen apps. When you install it, you'll be recommended to use a REPL wrapper for rlwrap. I've found that the one from the wikibooks site works better (i.e. at all).
Rich Hickey is an entertaining figurehead
Rich Hickey, creator of Clojure and designer of Datomic, the FP-friendly database system everyone's talking about, has some inspiring talks from the end of last year about Clojure and Datomic, and notably why everybody is doing programming wrong. There are some pretty strong views in the talks, but they're a refreshing take on the sociological patterns in our industry, and how project pathologies can be treated.
There's an active community
Many clojure developers are ex- or current-Rubyists. For example, Jay Fields maintains the expectations testing library (more on this below).
Clojure has artsy cred, too: there are several videos on the web showing Clojure being used for live music.
Syntax change requires healthy brain re-wiring and thought simplification
After spending so much time wrapping my head around object-oriented constructs and trying to work out how best to structure OO programs, it's a refreshing change to work with a functional language. Not having a CS degree, I'd previously tinkered with Scheme following a workbook. I wasn't put off by parentheses, but did have some fears that I'd be transported back to the bad old days of the top-level PHP namespace. I soon realised, however, that my beef with PHP was mainly the aforementioned comingling of state and logic, as well as the inconsistencies of method signatures and names.
Clojure philosophy is all about consistency and reuse. I've trained myself to believe that reuse is all about identifying concepts, naming them and adding an abstraction, often a named value object. I'm pretty attached to my explicitly named classes of values, like SubscriptionEvent or PersonName. This is largely in reaction to the recognisable OO smells like Primitive Obsession. The problems inherent in such smells generally melt away in the FP world, since you're encouraged to use the built-in types to provide equality and the like, and to use the common functions like map, reduce and so forth to achieve what you would do in OO with a value object's methods.
Web development is potentially full-stack
I've begun a project for playing around with the Compojure web routing library. Compojure forms the basis of many Clojure web apps, and I'm using that repository as a place to stick my learnings. I'm test-driving each new feature, so that it might serve as a reference for other newcomers on how to do TDD for Clojure web apps.
TDD is easy, fast and totally not banned.
Watching the Hickey talks, you might come away with the impression that the Clojure community is anti-TDD. However, there are some excellent developments going on in this area, such as the aforementioned Jay Fields' expectations library, which provides an achingly simple way to express intent in tests. See my first attempts at testing a web app for an example of this. Structural whitespace optional.
Monads still a mystery
One week just wasn't enough. See if you can figure it out and send me a postcard with a succinct summary.
Until next time!


text:
AKWESASNE — Terms outlined but never ratified in a 2005 land-claims agreement between the state and the St. Regis Mohawk tribe will be the starting point for renewed talks.
Gov. Andrew Cuomo and Tribal Council chiefs announced a deal Tuesday that ended the tribe's future withholding of a share of slot-machine profits and resurrected interest in settling the 31-year-old land-claims lawsuit the tribe has pending against the state as well as Franklin and St. Lawrence counties.
The tribe has released $30 million to New York state, half the profits collected since 2010 and withheld in protest to slot machines added to the Ganienkeh territory's bingo operation in Altona. Still in escrow is $30 million, withheld pending resolution of the land-claims suit.
Representatives from both counties are expected at the table when Cuomo convenes the first new negotiating session in Albany within the next 10 days, said Tribal Chief Ron LaFrance.
He led a news conference at the Akwesasne Mohawk Casino on Wednesday, when the Tribal Council emphasized its desire to have the longstanding issue resolved.
"Everything that was in the 2005 land claims is back on the table," LaFrance said. "We're the largest-growing community in the North Country. We have exploding population, with 400 people living in the Town of Massena and more in Fort Covington and Bombay.
"We recognized we don't have enough land base," he said. "We're looking to expand our economy, and the only way to do that is a larger land base.
The land-claims suit has been in court for 31 years, LaFrance said.
"They stuck us here in this place, and we want to defend our boundaries.
"We are reclaiming our cultural heritage. The governor knew we'd push back, and we needed our issues settled," he continued. "We won't go away; we can't go away. We're always here, and we can't pick up and leave.

subset: commoncrawl


text:
NYS Science, Technology, Engineering and Mathematics (STEM) Incentive Program
They NYS STEM Incentive Program provides a full SUNY tuition scholarship for the top 10 percent of students in each New York State high school if they pursue a STEM degree in an bachelor degree program and agree to work in a STEM field in NYS for 5 years after graduation. Applicants must complete and submit the NYS STEM application by August 15.
Click here for the NYS Higher Education Services Corporation (HESC) STEM webpage for more information, including the application.
Click here to review our financing checklist. This information is provided to ensure you complete all requirements so your financial aid will credit the fall bill in a timely manner. How to look for a job on campus, obtain proof of enrollment and other helpful information is included.
If you plan to attend Binghamton in the summer 2014, fall 2014, and/or spring 2015, and you need financial aid funding, remember to file your 2014-15 FAFSA beginning January 1, 2014.
For more information about summer aid, click here.
New and returning graduate students: 2014-15 Financial Aid Award offers will be emailed to a student's Binghamton email address, beginning July 1st.
Effective for loans first disbursed on or after July 1, 2014 and prior to July 1, 2015:
Once degree requirements are met, students are no longer eligible for federal aid funding for that degree.
Last Updated: 8/21/14


text:
The wait is over! Download the BeerAdvocate app on iTunes or Google Play now.
Get 12 issues / year of BeerAdvocate magazine for only $9.99!
Saranac High Peaks Lemon Ginger - Matt Brewing Company
Displayed for educational use only; do not reuse.
Ratings: 78 | Reviews: 25 | Display Reviews Only:
2.5/5 rDev -30.7%
07-24-2014 22:17:47 | More by atlbravsrno1
3.75/5 rDev +3.9%
04-29-2014 20:51:25 | More by atrocity
West Virginia
3.5/5 rDev -3%
04-13-2014 02:13:30 | More by spedprof
New York
3.25/5 rDev -10%
03-11-2014 22:07:53 | More by Evarigan
3.5/5 rDev -3%
02-10-2014 02:48:06 | More by Goldndomer
New York
3.49/5 rDev -3.3%
22 oz. bottle with no freshness date, consumed on 9-16-13.
A- Almost transparent light copper hue. Lots of tiny bubbles vigorously rising to the top. Really big, rocky, off-white head that mellows down to a respectable layer of froth that kept me company until the glass was drained. Unusual appearance for a saison, but let's get to smellin'.
S- Smells like a saison. It is very yeasty, fruity, and estery. I'm getting more overripe stone fruit aromas than anything lemon, ginger or hops.
T- There is a subtle and fruity initial sweetness, and it definitely nails the dryness that I look for in a saison. However, something about the flavor seems off, but not off enough to completely ruin the experience. Ok, now I'm getting the ginger! There is a prevalent boozy flavor that isn't horrible, but it isn't well hidden or what I would expect from a saison. Furthermore, the wheat malt isn't pronounced enough, and isn't pulling its weight. It is too dominated by the boozy flavor, and a not appealing bitter ginger. There is some lemon there too, but the malt and the hops are too hidden. There are also notes of raisins, grappa, and brandy.
M- Again the wheat isn't pulling its weight, which is evidenced by the body being too thin and lacking smoothness. The carbonation is under-whelming as well. The dryness is there in the finish, and along with the ginger, bitter lemon peel, and modest hop presence, leaves a pleasant tingly, warming sensation, which evolves into a welcome cool and almost minty sensation.
O- I'd like to say this would pair well with sushi, but I think the heavy-handed booziness would overwhelm and hide some of the subtleties of the more delicate types of fish. It doesn't have the ultra refreshing character that I love about saisons, and it tastes weighed down by the alcohol. I have a feeling this is likely a symptom of the brew not being as fresh as it should be. I will look for and will appreciate a bottled on date in the future. This is the first Saranac High Peaks series that I've had, and, while I appreciate the effort, I think there is still room for more care in their craft. I am going to enjoy finishing this bomber, but I won't be purchasing it again. However, I would certainly give the other High Peaks a try, and I'll continue to drink Saranac regularly as a local, budget option.
12-15-2013 22:11:22 | More by ElijahRivera
New Jersey
2.75/5 rDev -23.8%
A: Pale orange with a strong sense of macro-carbonation. Antique white frothy head is one inch and sits rather well. Soapy lace. Minium appeal.
S: Nose of light tart lemon, ginger spice, with flashes of sweet cinnamon and a light dry muskiness of grains.
T: Flavor was semi-dry lemon, ginger with a dash of cinnamon and musky grains that closely followed the nose. A bit stingent at first, lemon grass, fennel sweet, woodsy citrus and oranges, sour malt and candied fruit. Lightly dry, harsh, unpolished finish.
M: Syrupy, medium bodied, touch of sour caramel, acidic, lacks a defined crispness.
O: Overall average offering at best, im a pretty hard evaluater of saisons/farmhouses, love the style, and a hard one to replicate though there are a few good ones made here in the states. Look for a musky belgian yeast, crisp carbonation and spicy nature, this one was meh all around. Some alcohol glow. Grain base was rough, scratchy as well flavor, not particularly smooth or sharply defined.
09-16-2013 23:55:27 | More by beerthulhu
New York
3.75/5 rDev +3.9%
08-18-2013 14:42:20 | More by Cooker_stp
New Jersey
4/5 rDev +10.8%
08-08-2013 22:11:36 | More by wonothesane42
New Hampshire
3/5 rDev -16.9%
07-28-2013 01:41:10 | More by Satchboogie
New York
3.5/5 rDev -3%
06-24-2013 18:56:48 | More by Danimal1101
New York
3.75/5 rDev +3.9%
06-08-2013 22:22:14 | More by schaffer9252
New York
3.5/5 rDev -3%
06-07-2013 20:43:32 | More by civicm87
3.5/5 rDev -3%
06-01-2013 01:24:15 | More by TriageStat
3.75/5 rDev +3.9%
05-25-2013 00:23:41 | More by Janeinma
2.5/5 rDev -30.7%
05-09-2013 23:45:07 | More by tommyguz
New York
3.55/5 rDev -1.7%
Saranac Lemon Ginger Saison is a very lively, hazy, amber ale with a soft, elastic, off white head that is kept in place with the constant bubbling. Lemon and ginger are apparent in the aroma, along with notes of lemongrass, apple and black pepper. It's bright. It's pretty full bodied and reasonably smooth... until the finish. The finish is a little harsh and acidic. Yes, it tastes like a Saison with lemon and ginger. The phenols are enough to be obvious, but not overpowering. The ginger flavor is full but it doesn't have that dirty taste. It almost seems like candied ginger, but without the sweetness. The aftertaste is a bit bitter and a bit sour. The longer it lingers, the more it tastes like apple. This beer is a little kooky, but there are no faults. It doesn't seem to be a challenge to drink 22 ounces of this.
05-06-2013 01:46:01 | More by yesyouam
3.5/5 rDev -3%
04-23-2013 03:11:38 | More by Proclarush
North Carolina
4.24/5 rDev +17.5%
A - dark orangish yellow with a big, soft, white head that has good retention
S - belgian funk, lemon, spices
T - lemon, ginger, Belgian funk, apricot, peach, fruity esters, alcohol
M - smooth, well carbonated, medium bodied
This is a surprisingly intricate, complex, enjoyable beer from Saranac. It had solid depth and some really nice intricacies. I really enjoyed this beer.
04-01-2013 01:05:51 | More by tdm168
New York
4/5 rDev +10.8%
03-29-2013 19:54:35 | More by lovindahops
New York
1.25/5 rDev -65.4%
03-20-2013 23:44:44 | More by BGsWo22
New York
4.5/5 rDev +24.7%
03-14-2013 01:19:16 | More by GennyCreamAle
North Carolina
3.75/5 rDev +3.9%
03-09-2013 04:16:26 | More by kell50
New York
4.5/5 rDev +24.7%
03-04-2013 21:20:42 | More by Thunderchief
New York
3.5/5 rDev -3%
03-01-2013 16:22:07 | More by ejh06752
Saranac High Peaks Lemon Ginger from Matt Brewing Company
82 out of 100 based on 78 ratings.


text:
Upcoming Website Maintenance
The OMRI Website may be unavailable Tuesday, September 2, between 8:00 PM and 11:00 PM Pacific Time (11:00 PM - 1:00 AM Eastern Time) due to website maintenance. We apologize for the inconvenience, and thank you for your patience.
Generic Materials Search: fertilizers blended with sodium nitrate
1 result
1 items found.
View the OMRI Generic Materials List Glossary in PDF format here.
Click on the arrow or the material name to view more details about each material.
Fertilizers, Blended with sodium nitrate
Allowed with Restrictions
Crop Fertilizers and Soil AmendmentsSynthetic
Pending additional rule-making, the use of sodium nitrate blended with fertilizers shall follow these stipulations: Before October 21, 2012, operations shall not meet more than 20 percent of an organic crop's nitrogen requirement with sodium nitrate. On or after October 21, 2012, operators using sodium nitrate shall use it in a manner that maintains or improves the natural resources of the operation, including soil and water quality, and comply with crop nutrient and soil fertility requirements. A proposed rule regarding the use of sodium nitrate is forthcoming. (NOP Notice 12-1) See also CHILEAN NITRATE. See Glossary for definition of "Chilean nitrate."
205.105(a); NOP Notice 12-1


text:
Get in the Water
We are reaching that twilight time of the summer months when opportunities for swim trunks and seaside trips are dwindling. Especially for anyone living in, say, 40 of the 50 states, when icy water may keep anyone from jumping into the lake.
At this late point in the game, I fear we may have forgotten how fun the beach can be. It has gotten a bad rap for its sundrenched laziness. And we are all busy looking ahead to the back-to-schools and fall temps, already missing some of the prime beachfront real estate for your umbrella in the last weeks of August.
Though not as immediately hair-raising/thrilling/dangerous as the much-beloved Shark Week of summer television, I think think we can all find something at our nearest bodies of water. Beaches mean an unabashed opportunity for playfulness: getting buried from the neck down, elaborate sand castle plans, running along the water. Swimming until wrinkled! When else can you get people excited by saying,"Hey guys, let's all go dig a HOLE!!?" Probably the best open swim you can find this side of the YMCA– a Last Chance Summer Beach Romance for you + water.
Some helpful reminders to jog your beach memory:
- Straw hats and a nose of zinc oxide never go out of style. OK, they never go out of "fun".
- Underwater frisbee is a game that requires a decent amount of practice and lung capacity.
- Hermit crabs do not make lifelong pets. On the other hand, homemade seashell pictureframes are always a hit.
- You may not be planning on a sand-eating contest, but your picnic and the beach gods may know otherwise.
- Funny sunburn patterns will not be so funny tomorrow. (Insert serious sunscreen note here)
- We have way too many beaches here to be permanent landlubbers.
Remember that ever-present magic where the shore meets the water--the slow lap of the lake, the rushing in and out of ocean waves--and it looks different in every light. The early morning surfers of the coasts, the raucous late-afternoon boardwalk beach-goers, and the late night shell-seekers are all drawn for different moments of the experience. And some of the best parts of state or national parks are the areas beyond the water's edge. Climbing the dunes and exploring the paths, seeing where the inlets lead, and taking your fishing pole to the docks are all adventures beyond your beach towel. It's your choice, to nap or not.
So let's get some urgency, some fire under our be-swimtrunked behinds. Go to the beach! Whether that's a day trip to the coast, or the lake around the corner. Let's all pile into the cars, trains, bikes and get there. Cram everything imaginable into a picnic basket, because swimming is a hungry sport. Strap on that bathing costume and toe-in to the water.
The beach is boring? The beach is a wonder.
Flocking like the salmon of Capistrano,


text:
Parents will have a chance to discuss a plan to raise the GPA requirement for Henrico middle school athletes.
Parents can sound off Thursday night, during the school board meeting on Nine Mile Road.
The proposal would requiring middle school student athletes to have a 2.0 GPA starting this fall. If students don't make the grade, they'll first get a warning.
According to the rule, at sixth grade, kids will be notified about the GPA requirement to get them ready for the proposed rule. If grades come in lower than a 2.0 by 7th grade, students can only practice, and can't play until coaches see higher marks. Then by 8th grade, if things don't improve, kids can't play or practice.
The school board is having it's monthly meeting at the New Bridge auditorium at 6:30 p.m. Thursday.
This coming school year would be a test period. Full enforcement would happen in 2014. Mandatory tutoring is also being considered to keep students off the bench.
Copyright 2013 WWBT NBC12. All rights reserved.
P.O. Box 12
On Your Side
Video and Pics
All content © Copyright 2000 - 2014 Worldnow and WWBT. All Rights Reserved.
For more information on this site, please read our Privacy Policy and Terms of Service.


text:
Take a look at what caught Stephanie Woods' eye on the Morning Xtra:
A little girl is about to board a train for the first time and couldn't be more excited!
Too cute! Enjoy!
635 W. 7th Street
Cincinnati, OH 45203
Switchboard: (513) 421-1919
Newsroom: (513) 421-0119
Press releases: email@example.com
FCC Public File
EEO Report
Closed Captioning


text:
Bidding updateNews
November 23, 2002, 02:50 PM
Hey guys, just a quick update on the whole Sothebys, Book-5-card thing. We're talking to lawyers, but it looks like it could happen. Soon. TLC would incoporate as a non-profit charity corporation, and that can be done in a day (Monday, one hopes). If that happens, the rest is cake, and we could be looking at having everything set up this coming week, perhaps in time for Thanksgiving. So stick with us - because the Potter fans uniting for this would truly be a wonderful thing. We'll update you soon.


text:
business earnings tax
individual city earnings tax
Capital Projects
City Auditor's Office
City Clerk's Office
City Council Office
City Manager's Office
City Planning and Development
Convention and Entertainment Facilities
Human Relations
Human Resources
Mayor's Office
Water Services
News from City Hall
City Communications Office
City of Kansas City, Mo.
CONTACT: City Communications Office, 816-513-1349
FOR IMMEDIATE RELEASE: Oct. 19, 2010
Open houses scheduled to present Major Street Plan update
The City of Kansas City, Mo. will host three open houses to present an update of the City's Major Street Plan. The Plan defines Kansas City's major street network and locations where potential upgrades should occur. This update outlines future roadways and integrates them with surrounding land uses to facilitate future development goals and community needs.
Residents and community members are encouraged to attend to provide input on the plan.
The open houses will be held at the following:
Monday, Nov. 1, 5-7 p.m., Penn Valley Community College's Education Center Room 19
3201 Southwest Trafficway
Thursday, Nov. 4, 5-7 p.m., Hillcrest Community Center, 10401 Hillcrest Road
Tuesday, Nov. 9, 5-7 p.m., Ambassador Building, 12200 NW Ambassador Drive
A series of exhibits describing the Plan and the City's future street network will be available for review at each location. Short presentations will be given at 5:30 and 6:30 p.m. Those unable to attend may access an online interactive tool regarding the Plan anytime from Nov. 1-14 by visiting the City's Public Works website: www.kcmo.org/CKCMO/Depts/PublicWorks.
Since 2008, three City Departments - City Planning and Development; Parks and Recreation; and Public Works - have worked together to update the City's Major Street Plan.
The new Plan supports the idea of "Complete Streets," providing bicycle, pedestrian and transit accommodations. It also recommends right-of-way enhancements, such as landscaped medians, improving the overall look of our streets. For certain streets, the Plan proposes "road diets," which reduce the number of necessary lanes or right-of-way width.
The Plan's developers also created a dynamic travel demand model to forecast future infrastructure needs, such as the number of lanes on a street necessary to handle forecasted demand.
The open house will allow the public to provide valuable feedback that City staff can use to fine-tune the travel demand model. Public comments will also be used to help inform the Plan's implementation.
Any person with a disability who desires reasonable accommodation to attend this meeting may contact the City's 311 Action Center at 311 or 816-513-1313, or for TTY, 816-513-1889, or by e-mail at email@example.com.
For more information or media inquiries involving the Major Street Plan, please contact Blair Sells, Patti Banks Associates, at 816-756-5690, ext. 3040.
For more information about the City's Street and Traffic Division, please contact Dennis Gagnon, Public Works Department public information officer, at 816-513-2659.


text:
the little bouquet book
De Vanessa Hadady, BFA, MA
As a valentine or keepsake, in this simple format small scale book the artist offers just over thirty realist images that feature bouquets through a range of styles and subject matter... another type of little bouquet that will never need tending and may last generations ...
Acerca del autor
VANESSA HADADY is a third generation classically trained painter who began practicing formalized painting in 1974. She obtained a Bachelor of Fine Arts in painting from the University of New Mexico, Albuquerque, New Mexico. There, among several scholars, she studied under Gene Frumkin (poet), Joel-Peter Witkin (photographer), and Thomas Barrow (photographer) while sitting in critiques by Julian Schnabel (filmmaker/artist) and the late Joan Brown (artist). Ms. Hadady has received recognition by the National Museum of Women in the Arts Archive on Women Artists, Washington, D.C. In California, she has shown in Davis, Berkeley, San Francisco, Silicon Valley areas, while having pieces in private and corporate collections. During year 2010 she entered works into completion and won sweeping regional class/division awards. During the same year, one of her quotes was included in "Art Studio Door Signs" by Jerry Saltz (T. Ward, ed.). Her watercolor "California Valley" was scheduled into the
Fecha de publicación 30 de diciembre de 2012
Dimensiones Cuadrado pequeño 40 páginas
Papel estándar
Categoría Bellas artes
Conéctese o cree una cuenta para publicar un comentario.
Comience a crear su propio libro hoy desde 3.99 US $.
Sitios de Blurb


text:
Vilano Beach Oceanfront in St Augustine
- bedrooms 3
- baths 2
- sleeps 8
- pool no
- hot tub no
- pets allowed no
- type House
- community
rates (USD)
/ week
$ 2,500 - $ 2,500 / month
vacation rental description
Come and Relax on the large second story deck of this comfortable
Vilano Beach home which sits just feet away from the beautiful
Atlantic ocean. Step onto the beach from your back yard and fish for
a large variety of species, or comb the beach as you look for shells
and other treasures. If surfing is more your thrill, this can also
be found within a footballs throw from the home along with all the
other relaxing and exciting beach activities you can imagine. This
home is located just 2 miles from historic downtown St Augustine, 10
miles from the World Golf village, 7 miles from the huge outlet
malls, and an easy drive to many other beaches, golf courses, and
various recreation and dining activities. This home is well equiped
with all the comforts and boasts an amazing view of the ocean from
the living room, kitchen, and dinig room.
vacation rental location
property availability
- dates with deals
- unavailable dates
Last modified on 09-1-2014 at 1:53 PM.
email owner view full calendar
Trudy Reinhold 904-797-9923
house rental amenities
The property is comfortably furnished and has central heat and a.c.,
a fully equipped kitchen, washer and dryer, cable t.v., telephones,
outside shower, a large patio table, umbrella and lounge chairs for
soaking up the sun. There is also a wide selection of games, books,
beach toys, and a large stainless steel gas grill on the second
story deck for that oceanfront B-B-Q.
activities and attractions in St Augustine Atlantic Coast North
Fishing, swimming, surfing, and shelling all in your own backyard.
Shopping, golfing, fine dining, sightseeing, and many more activites
and events St. Augustine has to offer all within a short drive of
the house.
vacation rental rates
August - May : $1250 per week or $2500 per month
June - July : $1350 per week
$250 upgrade for holiday weeks and special events.
Trudy Reinhold 904-797-9923
accepted payment methods
Prior to paying a reservation deposit, always verify payment instructions by calling the phone number displayed on this listing page. By contacting the owner directly and paying by an approved method - credit card, paypal, check or bank transfer - your reservation payment will be protected up to $1,000.Learn more in our Security Center


text:
Faculty & Staff
Tim Cresswell
OFFICE LOCATION: 210F Renaissance Park
EMAIL: email@example.com
CURRICULUM VITAE: T. Cresswell C.V.
PhD Geography, University of Wisconsin – Madison, 1992.
World Regions, Global Urbanism, Space and Place.
Spatial Theory, Cultural Geography, Place, Mobility, Urban Cultures.
PUBLICATIONS (selected):Books
Cresswell T (2013) Geographic Thought: A Critical Introduction (Blackwell)
Cresswell T (2006) On the Move: Mobility in the Modern Western World (Routledge)
Cresswell T (2004) Place: A Short Introduction (Blackwell)
Translated into Chinese and published by Socio Editions, Taipei (2006).
Translated into Korean and published by Sigma, Seoul (2012).
Cresswell T (2001) The Tramp in America (Reaktion Books)
Cresswell T (1996) In Place/Out of Place: Geography, Ideology and Transgression (University of Minnesota Press)Edited Books
Cresswell T and Merriman P (eds) (2011) Geographies of Mobilities: Practices, Spaces, Subjects (Ashgate)
Cresswell T and Uteng P (eds) (2008) Gendered Mobilities (Ashgate)
Cresswell T and Verstraete G (eds) (2003) Mobilizing Place, Placing Mobility: The Politics of Representation in a Globalized World (Rodopi Editions)
Cresswell T and Dixon D (eds) (2002) Engaging Film: Geographies of Mobility and Identity (Rowman and Littlefield)Recent Papers and Chapters
Cresswell T and Martin C (2012). On turbulence: entanglements of disorder and order on a Devon beach. Tijdschrift voor Economische en Sociale Geografie 103/5: 516-529.
Cresswell T (2012). Mobilities II: Still. Progress in Human Geography 36/5: 645-653.
Cresswell T (2012). Non-Representational Theory and Me: Notes of an Interested Sceptic, Environment and Planning D: Society and Space 31/1: 96-105.
Cresswell T (2011). Value, gleaning and the archive at Maxwell Street, Chicago. Transactions of the Institute of British Geographers 37/1: 164-176.
Cresswell, T 2011, La Politica de la Turbulencia, In Beiguelman G & La Ferla G (eds), Nomadismose Technologicos. Dispositivos moviles. Usos masivos y practicas artisticas., Buenos Aires: Aerial, pp. 39.
Cresswell T (2011) Ergin Çavuşoğlu and the art of betweenness. In Martin C and Rigg J (eds) Spatialities: Geographies of Art and Architecture. London: Intellect.
Cresswell T (2011) Mobilities 1: catching up. Progress in Human Geography 35/4: 550-558.
Cresswell T (2011) Race, mobilities and the humanities: a geosophical approach. In Daniels S, DeLyser D, Entrikin JN and Richardson D (eds) Envisioning Landscapes: Making Worlds, pp. 74-83. New York: Routledge.
Cresswell T (2011) Mobility. In Livingstone D and Agnew J (eds) The Sage Handbook of Geographical Knowledge. London: Sage.
Cresswell T (2011) Place. In Agnew J and Duncan J (eds) The Wiley-Blackwell Companion to Human Geography. Oxford: Wiley-Blackwell.
Cresswell T (2011) The vagrant/vagabond: the curious career of a mobile subject. In Cresswell T and Merriman P (eds) Geographies of Mobilities: Practices, Spaces, Subjects, pp. 239-254. London: Ashgate.
Cresswell T (2010) Towards a politics of mobility. Environment and Planning D: Society and Space 28/1: 17-31.


text:
Log In
Add a message
Your e-mail
bill greene/globe staff
The Lexington Minutemen marched up West Broadway during the St. Patrick's Day parade in South Boston.
Revelers of all ages enjoyed the festivities on a warm Sunday.
This float carried St. Patrick through South Boston.
Bill Greene/globe staff
US Senator Scott Brown appeared alongside his daughter, Ayla, left, and his wife, Gail Huff.
Even the youngest in attendance made sure to wear green.
Bob Wickoff of the Tony Barre Band was joined by revelers for a quick dance.
Subscriber Log In
Don't miss any of your favorite stories again. Read the stories that matter to you as much as you want, whenever you want when you subscribe to BostonGlobe.com.
Get full access today for just 99¢
E-mail address:
Forgot your password?
Home delivery subscribers get free access. Link Account
Customer Service Number: 1.888.MY.GLOBE
Receive free unlimited access to BostonGlobe.com for the next two weeks! Get access
Enter your e-mail address below. We'll send you an e-mail with a link to reset your password.
E-mail Address
Return to login
Continue reading by subscribing to BostonGlobe.com for just 99¢.


text:
At each event, there were large crowds of people who came out on a beautiful Saturday to help someone in need.
Clark, the son of Jasper Fire Chief David Clark and his wife Sherry, is currently hospitalized at Children's of Alabama undergoing chemo treatments, and no doubt his family is more than appreciative of the love and support that's been shown for their son in the past two weeks.
It's heartwarming to see that kind of support for a young person who's going through the most difficult battle of his short life.
It's our hope that that kind of support will continue to be shown for Clark and for any other resident of Walker County who needs love and compassion and a little help when facing such a difficult time in their life.
— The Daily Mountain Eagle


text:
It is rare and exciting to find cars so well preserved, and in their original condition. This 1963 Jaguar Mark II 3.8 Sedan is... More
1962 Jaguar MKII 3.8 1962 Jaguar MKII 3.8, 4 speed, overdrive, air, power brakes and steering, white with red leather interior, outstanding mechanical and cosmetic... More
The Jaguar Mark 2 is a medium-sized saloon car built from late 1959 to 1967 by the Jaguar company in Coventry, England. For the... More
The Jaguar Mark 2 is a medium-sized saloon car built from late 1959 to 1967 by the Jaguar company in Coventry, England. For the... More
Desirable 4-Speed with Overdrive Very Original Matching Numbers 3.8L Example Delivered New to Princeton Playwright John O'hara Same Documented Owner Since 1970 Rare Original Colors Complete with Manuals, Tools,... More
1962 Jaguar MK 2 Completely restored, paint, undercoat, electric, carpet and lights (even the front fender running lights). All parts of this vehicle is... More
JAGUAR: 1967 Mk II project, 3.4, 4-speed o/d, wire wheels, original car is complete and body could be repaired, comes with spare body and... More
1967 Jaguar MK 2, 3.4 L, 4 speed Rebuilt Engine, Rebuilt Clutch, Brake and Slave cylinders as well, Chrome is Perfect, Body is solid... More
1967 Jaguar MK 2, California car, laser straight. Weber carbs, Willwood brakes, Pertronix, Coombs spats, electric radiator fan. Strong running car, starts easily. Chrome... More
JAGUAR: 1962 Mark II 4-door sedan, not running, good condition, $4,500. 972-247-2007, TX; [email]... More
The Jaguar Mk.II is a medium sized saloon car built between 1959 and 1967 in Coventry as successors to the Jaguar 2.4 litre and... More
JAGUAR: 1968 Mark II, gunmetal/red, matching numbers, 3.8 with overdrive, stick, same owner since 1970, a nice driver quality car, asking $32,500 obo. LBI... More
JAGUAR: 1961 Mk 2, complete professional restoration by Autocats, Essex, UK; 3.8 with 4-speed and overdrive, indigo blue w/red Connolly hides and red Wilton... More
1968 Jaguar MK 2 340 4-door, second owner, excellent glass, chrome, interior and condition. Winter air tight bagged. Daily driver and drives like a... More
JAGUAR: 1967 Mk II, white/black, beautifully sorted and structurally excellent, 3.8 numbers matching engine, fitted with 5-speed, rack and pinion steering, aluminum radiator, stainless... More


text:
DNR, Others Warn Against Feeding Minn. Wolves
Posted at: 08/23/2013 9:56 AM
| Updated at: 08/23/2013 9:58 AM
BRIMSON, Minn. (AP) - Worried about wolves becoming too bold around humans, Minnesota wildlife officials are stepping up warnings to people not to feed the animals increasingly wandering along northeastern Minnesota roadways.
The campaign has taken on special significance north of Duluth, where tourists are looking to catch glimpses of wolf pups sometimes by leaving food on the roadside. The pups have readily approached vehicles Minnesota Public Radio News reported Friday.
Assistant Department of Natural Resources wildlife manager Nancy Hansen says the pups use the stretch of forest near the intersection of two county highways as a rendezvous site while adults in the pack leave to hunt. She says officials cannot relocate the pups, because they would either die away from the pack or just return to the area.
Information from: Minnesota Public Radio
(Copyright 2013 The Associated Press. All rights reserved. This material may not be published, broadcast, rewritten or redistributed.)
|Print Story


text:
& Deals
& Celebrations
or Login
Join FREE
Log In
This egg bake recipe starts with an easy refrigerated pie crust filled with cheese, corn and salsa for a Mexican-inspired flavor fiesta! From Tina Repak-Mirilovich, Bake-Off® Monthly Challenge.
©2013 General Mills, Inc. All Rights Reserved. This information will only be used to send an email to your friend(s) and will not be saved. Please read our Privacy Policy.
Wild Rice and Ham Country Tart
Chicken-Asiago-Spinach Quiche
Sausage and Egg Biscuit Bake
Muffuletta Quiche Cups
Overnight Brunch Egg Bake
Pesto-Quinoa-Spinach Quiche


text:
johnbron wrote:Hey David, I thought that if Canada had got there first we would all be welcomed with a BIG
"Chown's Used Tractor Parts"
JB, the tractor parts sign is just over the next rise!!
Mars rover, why it really lost communication with NASA?
All non-Cub/Cadet/IH/Farmall/Case tractor and machinery discussions.
Moderator: Team Cub
Forum rules
Notice: For sale and wanted posts are not allowed in this forum. Please use our free classifieds or one of our site sponsors for your tractor and parts needs.
JB, the tractor parts sign is just over the next rise!!
V.P. of T.S.A. (taking stuff apart)
Hey Rudy ole boy
Careful them's fightin words there The First Timmies was on the corner of Ottawa and Dunsmuire Sts. in good old Hamilton Ontario(Canada) Don't you be giving that one to Hogtown
I taught TO had it, but you are right - it was in the steel town and not hog town.... oh well, this ole brain is startin to slip!
Confusion breeds Discussion which breeds Knowledge which breeds Confidence which breeds Friendship
Return to Other Tractors and Machinery
Who is online
Users browsing this forum: No registered users and 3 guests


text:
REHOBOTH BEACH, Del. - A young child was rushed the hospital after falling from a balcony early Friday afternoon.
Rehoboth Beach Police say they were called to Snug Harbor complex in the North Shores Community north of Rehoboth, just after 12:30 PM. Initial investigation shows that the 1-year-old girl fell two stories, landing on the pavement below.
"That's really sad, no young kids in my family, but I can't even begin to imagine," said one neighbor.
"It's just sad to hear, 1 year-old child...yeah...anything can happen," said another.
The child, who was visiting with her family from Pennsylvania, was taken by ambulance to Rehoboth Elementary, where she was flown by helicopter to A I DuPont Children's Hospital, with unknown injuries.
Due to the nature of incident information is limited, we will bring the very latest as it is available.


text:
Biomedical Library's Fourth Annual "Best Use of Literature" Poster Prize
The Biomedical Library's "Best Use of Literature" poster prize will be awarded in January, 2013, in conjunction with the School of Medicine's poster presentation event for the NIH Summer Scholars, students from the MSTAR program, and pharmacy students doing summer research. This prize is awarded to two posters in recognition of outstanding use of resources and demonstrating that in a poster. The award is $125.00 each*.
All who wish to be considered for the prize are asked to submit a short essay reflecting on their research process. The deadline for entry is noon on January 9, 2013. Additionally, the posters will be judged to evaluate the use of references within the poster.
Please send your essay to Karen Heskett at firstname.lastname@example.com. Please be sure to include your name and the title of your poster in the email message.
In your short essay (about 500-750 words, and no more than 750 words), please:
Note: you do not need to answer all of the above questions.
In addition to the short essay, a panel of judges will evaluate the posters for:
* Note: due to University rules, if you are in the payroll system, the maximum award we can give is $75. Also, if the award is for the full $125, it is taxable.


text:
Posted: 8:31 pm Monday, March 2nd, 2009
Treasure Coast LB Jeff Luc is area's third All-American
By Jason Lieser
As his recruiting prospects surge, Treasure Coast linebacker Jeff Luc bolstered his status even more by earning invitations to both major All-American bowls.
Luc (6-1, 235) has not decided whether he will play in the U.S. Army game in San Antonio or Under Armour's event in Orlando. Playing in Orlando appeals because more of his family would be able to attend.
"I'll decide whenever they give me a deadline," Luc said. "It's a blessing to be invited and it's an opportunity not everyone gets."
Luc joins two other area juniors who already have accepted offers to play in one of the two games. Dwyer linebacker Matt Elam will play in the U.S. Army game, while Royal Palm Beach's Chris Dunkley will head to Orlando next January. All three players were picked in the early selection process.
Luc has emerged as one of the area's most heavily recruited players for the Class of 2010. He runs the 40-yard dash in 4.65 seconds, bench presses 325 pounds and squats 700. He has at least 16 scholarship offers with more likely on the way.
He has been offered by the big three in state, Southern Cal, Georgia, Notre Dame, Nebraska, Michigan, North Carolina and many others. He has drawn interest from Alabama, Ohio State, LSU and Auburn.
"The phone's been ringing and it hasn't stopped," Treasure Coast coach Bill Kelley said. "He's got some real God-given talent. He's got closing speed and he brings ridiculous hits."
Luc said the Florida Gators are his favorite right now, but said he is open to every school with interest in him and does not plan to commit any earlier than this fall.


text:
When assessing the severity of rheumatoid arthritis, doctors consider your symptoms, joint damage, and physical function. Symptoms of severe rheumatoid arthritis include a high level of joint pain, stiffness, or swelling of the affected joints. You may have trouble performing your usual daily activities. Joint deformities, especially hand deformity, are common with severe rheumatoid arthritis. The condition can also affect other organs in your body, leading to symptoms such as persistent fatigue.
While physical examinations, laboratory tests (including CRP and erythrocyte sedimentation rate), and imaging studies can help your doctor determine the severity of your condition, your own self-assessment is important too. For example, how long does morning stiffness last? Have symptoms, including your pain and fatigue levels, worsened? How is rheumatoid arthritis affecting your daily activities, family life, leisure time, and work?
The goal of treating rheumatoid arthritis is to manage symptoms, minimize damage, and prevent disability. Early diagnosis and treatment is essential. But even with an aggressive treatment plan, there is no arthritis cure, and there is no guarantee that the disease will not progress from mild to severe.
What can you do to stave off severe rheumatoid arthritis? Start by learning all you can about the disease. When symptoms first occur, consult a doctor or rheumatologist. Decide on a treatment plan with your doctor. Be compliant with the treatment plan. Be open and honest with your doctor about changes in your condition or any concerns that develop.
Rheumatoid Arthritis Quizzes
Rheumatoid Arthritis Screening Quiz
Do you have symptoms of rheumatoid arthritis? Early diagnosis of rheumatoid arthritis and early, aggressive treatment can help prevent joint damage and deformity.
Rheumatoid Arthritis - Test Your Knowledge
Rheumatoid arthritis is an autoimmune disease. How much do you know about rheumatoid arthritis -- a chronic, inflammatory type of arthritis?
Rheumatoid Arthritis Or Osteoarthritis: Which Is It?
Two of the most common types of arthritis are osteoarthritis and rheumatoid arthritis. Do you know the difference?
Rheumatoid Arthritis Or Lupus: Which Is It?
While rheumatoid arthritis and lupus each have their own sets of symptoms, there are also some symptoms that overlap between the two diseases. Do you know the difference?
Rheumatoid Arthritis - Basic Information
Rheumatoid Arthritis - The Basics
Check out this overview of rheumatoid arthritis -- one of the most disabling types of arthritis.
10 Things You Should Know About Rheumatoid Arthritis
Rheumatoid arthritis affects 1.3 million Americans, and three times as many women as men. There are important facts you should know about rheumatoid arthritis.
Rheumatoid Arthritis: Explained With Pictures
Rheumatoid arthritis primarily affects your joints, but it can cause symptoms throughout your body. These photos help explain rheumatoid arthritis.
Guide to Rheumatoid Arthritis
Rheumatoid arthritis causes pain, swelling, stiffness, and loss of function in the joints. Learn more with our five-part guide to the cause, diagnosis, symptoms, and treatment of rheumatoid arthritis.
Rheumatoid Arthritis 101: Free E-Course Newsletter
Better understanding of rheumatoid arthritis will enhance your ability to manage the condition. Learn more about rheumatoid arthritis in our free newsletter e-course.
Signs and Symptoms of Rheumatoid Arthritis
How to Recognize the Signs and Symptoms of Rheumatoid Arthritis
Recognizing the signs and symptoms of rheumatoid arthritis will lead to an accurate diagnosis and treatment plan. See your doctor if you are experiencing symptoms that may be related to arthritis.
Rheumatoid Arthritis Prognosis - How Soon Will Symptoms Worsen?
Questions about the prognosis of rheumatoid arthritis typically follow diagnosis. Patients want to know how bad the disease will get, how soon symptoms will worsen, and what their future holds.
Arthritis Hand Photo Gallery
Hand damage and deformity caused by arthritis can include nodules, swelling, stiffness, ulnar drift, contractures, and other problems. These photos of hands damaged by arthritis help explain the symptoms.
Rheumatoid Arthritis Hand Deformity: Is It Inevitable?
Rheumatoid arthritis hand deformity is a common symptom of the disease. Is it inevitable? Can it be prevented?
What Defines a Remission in Rheumatoid Arthritis?
Clinical symptoms of rheumatoid arthritis can lessen for a period of time. What defines a true remission in rheumatoid arthritis patients?
What Is Rheumatoid Factor?
Explanation of the significance of rheumatoid factor.
What Is A Rheumatoid Nodule?
Firm nodules beneath the skin may develop in about 25% of rheumatoid arthritis patients. See what they look like.
Treatment of Rheumatoid Arthritis
Rheumatoid Arthritis Treatment - 2012 ACR Recommendations
The American College of Rheumatology has updated guidelines for using DMARDs and biologic drugs to treat rheumatoid arthritis.
Is There Advice for Patients With Long-term Rheumatoid Arthritis?
There is a lot of advice for newly diagnosed rheumatoid arthritis patients, mostly regarding early diagnosis and treatment. What advice is there for patients who have already lived with the disease for 5 or 10 years?
Primer on the Rheumatic Diseases. Arthritis Foundation. Thirteenth Edition.


text:
Funeral services will be held today, Wednesday, Nov. 27, 2013, at 2 p.m. at the First Baptist Church in Cordova. Burial will be in the Old Mt. Carmel Cemetery in Cordova. Brother Mahlon LeCroix will officiate.
Visitation was held Tuesday, Nov. 26, 2013, from 6 until 8 p.m. at Nichols Funeral Home in Addison.
Sargent is survived by her children, Aneitha (Tommy) O'Rear, Awania (Allen) Feltman and Sherman Johnson; grandchildren, Tony Cornelius, Aaron (Terina) Johnson, Andreona Jent (Will) Sides, Takota O'Rear, Summer Feltman and Austin Feltman; four great-grandchildren, Hunter Jent, Chevy Johnson, Wade Johnson and Starri Sides; brothers, Don (Joanne) Sargent, David (Jean) Sargent; sister, Brenda (Rodney) Malloy; sister-in-law, Sheila Sargent; and a host of nieces, nephews, family and friends.
She was preceded in death by her parents, Owen Joseph and Norma Kay Sargent; and brother, Danny Joe Sargent Sr.
Nichols Funeral Home, Addison; 256-747-6063


text:
- Classifieds
- Carbondale Apartments
- About the DE
- Contact
- Advertising
- Archives
Students dance to the fundraising beat
One Registered Student Organization partied for a cause Saturday. The first all-night Saluki Thon took place Saturday at the university's Recreation Center. The six-hour music and dance marathon went from 8:00 p.m. until 2:00 a.m. and featured live ... Continue Reading →


text:
TOLEDO, OH (Toledo News Now) - With a week to go before the November election, Toledo Mayor Mike Bell and Council members Steve Steel and Lindsay Webb are unveiling how some of the new tax revenue would be spent if voters approve Issue 5.
It is the 10-year, 1-mill levy request on the ballot, which would create a dedicated funding stream for parks and recreation facilities and programs.
They say a portion of the revenue generated would be earmarked to build a new water park featuring slides and waterfalls, as well as an aquatics center for seniors which would be built next to an existing senior center.
"In the suburbs they do this on a regular basis. What we need to do inside the city we need to have the same quality of life they have in the suburbs," said Mayor Bell.
"We have to dedicate and invest into our parks into our recreation and bring Toledo parks and recreation into the 21st century," said Councilman Steel.
While that would commit roughly $8 million from the $30 million generated by the levy over 10 years, Councilwoman Webb said the city would still be committed to keeping its neighborhood pools open.
"We will be making capital investments but we will also be enhancing the facilities and the infrastructure we have," said Webb.
If approved, the average Toledo home owner would be an additional $18 per year.
Copyright 2012 Toledo News Now. All rights reserved.
730 North Summit Street
All content © Copyright 2000 - 2014 Worldnow and WTOL. All Rights Reserved.
For more information on this site, please read our Privacy Policy and Terms of Service.