 one place. Most often, talking to a friend was merely a matter of walking across the lunch room--and that was only if that friend wasn't already sitting at my table. Even if we didn't get to talk or spend a whole lot of time together, at the very least we saw each other at some point every day. I didn't hang out with or even like everyone in high school, but they were all there. I saw them; I passed them in the halls; I had classes with them. They weren't just pictures and text on Facebook.
Ah, Facebook. Thanks to Facebook, I know more about what's going on in my friends' lives now than ever before. But comparatively, I never see or really talk to them. I mean, I try to spend time with what friends I can, and I do okay considering everything else I'm up to. In general, the people I hung out with the most in high school are the ones I'm still hanging out with now. It's really nice; I'm grateful to have them, and the fact that they're still around after all this time means a lot to me. But we're quite a bit more scattered now, and our schedules have become such that it's difficult to pull everyone together very often.
I'm not complaining about that, because it's growth. We're all progressing in our own ways, and I believe our lives are richer now than they were back in high school. But there's still a lesson to be learned from the comparison between high school and now: the value of real, offline interaction. Watching those old seminary videos brought back a forgotten sense of appreciation for everyone I went to school with, from closest friends to passing acquaintances. It's the kind of appreciation that can't be adequately expressed on the Internet; it's something just for the real world. In our day of information on demand, that's probably one of the most important things someone can learn.
And that's why I have no problem writing a post today about high school. We don't have to live in the past to reflect on and learn from it. Looking back, I see so much more that I can apply in my life today than just what was needed for me to graduate. For instance, another lesson from reviewing the high school experience might be one in time management and structure. I was always late for school back in the day. I hated getting up early, and couldn't wait to get home once the last bell rang. I would have rather used my time as a permanent vacation: no deadlines, nowhere to be. But since then I've grown up just enough to realize I need structure. I need goals. I need plans. I need follow-through. And I look back at my school experiences for an example to follow: important things first, a little bit of free time (but not too much) between tasks in order to rejuvenate, things like that.
And the list of lessons goes on.
So, here's to high school. Thanks for the memories.
Saturday, July 2, 2011
High school credit
Posted by Nathan at 6:47 PM
Labels: Past Blast, Thoughts
1 comment:
Did I mention, great vid?require 'chef/provisioning/aws_driver/aws_resource'
require 'chef/provisioning/aws_driver/resources'

# Common AWS resource - contains metadata that all AWS resources will need
class Chef::Provisioning::AWSDriver::AWSResourceWithEntry < Chef::Provisioning::AWSDriver::AWSResource

  #
  # Dissociate the ID of this object from Chef.
  #
  # @param action_handler [Chef::Provisioning::ActionHandler] The action handler,
  #        which handles progress reporting, update reporting ("little green text")
  #        and dry run.
  #
  def delete_managed_entry(action_handler)
    if should_have_managed_entry?
      managed_entry_store.delete(self.class.managed_entry_type, name, action_handler)
    end
  end

  #
  # Save the ID of this object to Chef.
  #
  # @param aws_object [AWS::EC2::Core] The AWS object containing the ID.
  # @param action_handler [Chef::Provisioning::ActionHandler] The action handler,
  #        which handles progress reporting, update reporting ("little green text")
  #        and dry run.
  # @param existing_entry [Chef::Provisioning::ManagedEntry] The existing entry
  #        (if any).  If this is passed in, and no values are changed, we will
  #        not attempt to update it (this prevents us from retrieving it twice).
  #
  def save_managed_entry(aws_object, action_handler, existing_entry: nil)
    if should_have_managed_entry?
      managed_entry = existing_entry ||
                      managed_entry_store.new_entry(self.class.managed_entry_type, name)
      updated = update_managed_entry(aws_object, managed_entry)
      if updated ||!existing_entry
        managed_entry.save(action_handler)
      end
    end
  end

  def get_id_from_managed_entry
    if should_have_managed_entry?
      entry = managed_entry_store.get(self.class.managed_entry_type, name)
      if entry
        driver = self.driver
        if entry.driver_url!= driver.driver_url
          # TODO some people don't send us run_context (like Drivers).  We might need
          # to exit early here if the driver_url doesn't match the provided driver.
          driver = run_context.chef_provisioning.driver_for(entry.driver_url)
        end
        [ driver, entry.reference[self.class.managed_entry_id_name], entry ]
      end
    end
  end

  # Formatted output for logging statements - contains resource type, resource name and aws object id (if available)
  def to_s
    id = get_driver_and_id[1]
    "#{declared_type}[#{@name}] (#{ id? id : 'no AWS object id'})"
  end

  protected

  #
  # Update an existing ManagedEntry object.
  #
  # @return true if the entry was changed, and false if not
  #
  def update_managed_entry(aws_object, managed_entry)
    new_value = { self.class.managed_entry_id_name => aws_object.public_send(self.class.aws_sdk_class_id) }
    if managed_entry.reference!= new_value
      managed_entry.reference = new_value
      changed = true
    end
    if managed_entry.driver_url!= driver.driver_url
      managed_entry.driver_url = driver.driver_url
      changed = true
    end
    changed
  end

  def get_driver_and_id
    driver, id, entry = get_id_from_managed_entry
    # If the value isn't already stored, look up the user-specified public_ip
    driver, id = self.driver, self.public_send(self.class.aws_id_attribute) if!id
    [ driver, id ]
  end

  def self.aws_sdk_type(sdk_class,
                        id: :id,
                        managed_entry_type: nil,
                        managed_entry_id_name: 'id',
                        backcompat_data_bag_name: nil,
                        **options)
    super(sdk_class, id: id, **options)
    @managed_entry_type = managed_entry_type || resource_name.to_sym
    @managed_entry_id_name = managed_entry_id_name
    if backcompat_data_bag_name
      Chef::Provisioning::ChefManagedEntryStore.type_names_for_backcompat[resource_name] = backcompat_data_bag_name
    end
  end

  def self.managed_entry_type
    @managed_entry_type
  end

  def self.managed_entry_id_name
    @managed_entry_id_name
  end

  def should_have_managed_entry?
    name!= public_send(self.class.aws_id_attribute)
  end
end
If you’ve tried budgeting and failed, you’re not alone. I tried budgeting for years without success. Being a bad budgeter always made me feel like a financial failure until I realized that the problem wasn’t me. It was all of the extreme budgeting advice that’s pushed by the finance industry, especially to women.
According to research from Starling Bank, 90% of money articles in women’s magazines suggest that we should spend less. We’re constantly bombarded with messaging that buying shoes, handbags, and makeup are frivolous and the cause of our financial woes. Because of this, we unconsciously develop the idea that any feminine purchase we make