Skip navigation

Category Archives: Uncategorized

My daughter Maggie, who I’ve mentioned on here before, has some major issues (undiagnosed as of yet) that have caused her considerable developmental delays.  This past Sunday was a major breakthrough for her, and my wife has done a fine job of summing it up for those interested in reading it.

I’m not really sure WHAT inspired me to come back and give it a try again…

When it first released and I bought it (being a long time fan of Turbine games) I really enjoyed it.  The game offered multiple layers to it’s (at the time only) PvE element for both customization and character development, it had a rich overarching story telling system (similar to the now defunct AC2), and great universe integration.  It had about everything I enjoy in an MMO, but for whatever reason, it didn’t grab me.  Perhaps it was due to the clunky skill systems, or the over all busy nature of the games complexity, but it just felt wrong after I got past my 20s/30s in the game.

Navigation was a headache, and often times, the little to no reward I started seeing from the quest lines began to leave me wanting more.  The amount of work required to do basic things, such as combat, also began to wear on me (I was a loremaster, which is a very inventive great class). 

However, several expansions, engines, and a pay model change later I’ve decided to give it a go again; here are my initial impressions upon returning (some of these I’ve experienced from recent jaunts back as well):

  • Graphics have improved
  • Character responsiveness still not what I’d like to see
  • Storylines have become richer
  • Customizations have branched further
  • PvP is a nice addition, but meh
  • Soloing feels easier
  • Free to Play model seems implemented fairly well
  • Long term game play feels more promising than before

So lets discuss these points a bit more.

DX11 has been integrated, aside from some differences in the shadows, soft particles, and some interactive water effects (not sure why this wasn’t done prior to DX11) I don’t see a huge difference from the previous DX10 and DX9 iteration.  Textures (although high res versions have been available for a while) still don’t offer anything new, no tessellation, I don’t suspect or expect them to redo all the in game textures and engine, especially since I already find the game quite beautiful but the tech in me always wants to see rendering boundaries pushed.  Mind you I’m on an SLI rig that is DX11 capable, I WANT to make use of that when I game.


 

Character responsiveness has always been a bit of a nagging point for me in Turbine games since their original Asheron’s Call.  I can only assume it’s something to do with their code that requires server response before the client will report movement.  Most online games allow the client to dictate to the server it’s position and the server simply analyzes that and agrees or disagrees with the client.  This is called client-side prediction and has been in use in multiplayer games since the days of Quake at least.  Wikipedia states that Duke Nukem 3D used it as well, but my first real taste of the difference came from shifting out of native Quake DM into QuakeWorld DM where it existed, but I digress. It might even be that Turbine engines USE a form of client-prediction that requires some sort of start receive message before engaging client control, I don’t know, but it causes the client side experience to feel delayed to some extent.

So what does that all mean in a practical scenario? It basically means, when I press forward, either I move forward, or I have to wait a split second or more before my character moves forward.  Both can create unfavorable gaming moments, but I feel that the method in place in Turbine games has been problematic since it’s inception, especially given the responsive nature of their game mechanics.  The thing of it is, in their current design, you are less likely to be called back to a previous position (rubber banding) but rubber banding generally only happens in the most extreme of latency/packet loss cases.  So to avoid rubber banding (I suppose) they verify client input prior to client output, and I see a delay before I can change my X Y or Z position in the game world. 

I would be remised though if I didn’t mention it’s game integrity benefits though as well.  It protects the server from being deceived by client-side “trainers” or utilities that can report illegal positions used to exploit game mechanics.  Anyone who’s played WoW and knows about people porting and speed hacking etc, these are fundamental vulnerabilities to that technical design.  Tolerances usually exist in client prediction to allow a client to get from point a to point b without having to report every step across the grid.  That tolerance NEEDS to be there or you would see a lot of rubber banding, this is what allows smooth game play on really bad connections.  However, it’s easy to exploit that relationship by passing bogus packets to the server.  Both require creativity to overcome their hurdles, and they both do so well enough.  For me personally I feel with client prediction you open yourself to more administrative headaches in an MMO, but a better customer experience.  So I can’t help but feel it’s non-use is a form of laziness at the cost of the gamer.  One could reason it improves customer experience by insuring a level playing field but lets just move on.


 

Storylines, customizations, soloing, and PVP aren’t NEW features per say, but they are features that didn’t exist or have become more robust since it’s release in 2007.  They’ve got 2 expansions and a 3rd on the way so there has been and will still be growth in this game.  It, like a fine wine, has matured rather nicely.  I’ve also been a fan of Turbine’s story telling, and LotRO is no different, and only continues to prove (to me) their mastery in the medium of engaging RPG content in an MMO.  They’ve revamped their starting story lines, and added more tie ins to their quest chains, they introduced new methods for questing/instancing/booking called skirmishes as well.  I could go on for a long time about all the methods they have taken to make their storylines relevant and effective to meet game play but it’s something one has to experience I think more than read about.  The addition of their PvP system (called PvM for Player Versus Monster) even insures story integration into their game by forcing players to spin off new evil characters strictly for PvP.

The other aspect of the game I’ve always found intriguing is their deeds, titles, outfitting, traits, and dying systems.  All offer a robust amount of options for character diversity in their own right, but can really offer diverse customizations when the sum of all parts come together.  Mind you, like all MMOs, people will MIN/MAX so some of the traits etc become pretty cookie cutter for what is used, but it’s not from a lack of options that’s for sure.  They’ve continued to add to these systems, and at times it leaves my head swimming trying to keep track of them all, I tend to be a meta gamer so information overload is definitely something I suffer from when reviewing the possibilities.

The solo aspect of the game also seems to be more realistic than it was at release.  Not so much that you can check out when you are playing, but enough that one can keep a decent rate of progression while going at it alone.  Also some of the earliest content that was at one time a guaranteed group event has been scaled back.  Some may complain it’s TOO easy now, and they may be right, but I feel it’s found a sweet spot.


 

They’ve also converted to a Free to Play gaming model which seem to be all the rage now with MMOs (Thanks Korea!).  For anyone not familiar with a standard F2P gaming model it’s simple, offer a game for free, gut some features out and reserve them for 1) subscribers 2) one time game purchase 3) micro transactions.  In a nutshell, like selling crack.  The first one’s always free!

But seriously, it’s a clever business model, for a guy like me it gives me a demo of what I’m going to invest in and leaves me the option of giving my monthly sub since I’ve no issue with that (and haven’t since I really started into MMOs back in 97/98).  There is also a warm fuzzy seeing an itemized list of things you are getting for your money.  Mind you, it’s all nonsense and I am aware of that, but “if I pay monthly I get…” definitely passes through my mind as a comfort statement when I’m looking at F2P games.  This one of course being no exception, I’m not a huge fan of micro transactions, I’d rather lease the service than commit to it.

At any rate, it’s flexible, and playable even if you want to go in on the cheap.  Kudos to them for making that transition, and congratulations on their success with it.


 

Overall I feel the long term playability of the game has vastly improved, but it’s definitely got it’s competition like all other games.  There appears to be plenty of high end content and customizations to chase after.  There’s also multiple facets to their storylines as well that are worth exploring that I think give incredible replay value to their game.  I suppose I’ll keep going with this for a while in my free time as my fill in game.

If you are interested, look for me, or mail me in game on either Lotekend or Jahosi.

Link!!11!1!

Johan Arwidmark just posted today a quick guide on finding/extracting the Trace64.exe log reader from CM 12.

Ok, why does that matter?

Because reading logs inside PE with notepad is horrible…..

notrace 

VS.

 

trace

 

Have a great day!

image

Yup…

My wife’s birthday post for me!  I’m a very blessed man indeed.

As I was reading my bible this past Saturday morning I came across these verses.

2 Kings 22:16-20 ESV

Thus says the Lord, Behold, I will bring disaster upon this place and upon its inhabitants, all the words of the book that the king of Judah has read. Because they have forsaken me and have made offerings to other gods, that they might provoke me to anger with all the work of their hands, therefore my wrath will be kindled against this place, and it will not be quenched. But to the king of Judah, who sent you to inquire of the Lord, thus shall you say to him, Thus says the Lord, the God of Israel: Regarding the words that you have heard, because your heart was penitent, and you humbled yourself before the Lord, when you heard how I spoke against this place and against its inhabitants, that they should become a desolation and a curse, and you have torn your clothes and wept before me, I also have heard you, declares the Lord. Therefore, behold, I will gather you to your fathers, and you shall be gathered to your grave in peace, and your eyes shall not see all the disaster that I will bring upon this place.’" And they brought back word to the king.

It’s so amazing to see Gods mercy poured out continually throughout the bible. Though he would be fully justified to lay Israel low, he preserves it, for a time, as a mercy to his repentant servant.

Showing again, God loves a contrite heart. Its humbling to realize how far gone we can be, yet find forgiveness in the presence of an infinitely righteous God.

Especially when we as fallen beings can find it so hard to forgive others of such minor trespasses…

I’ve always been a bit of an older person at heart.  I never really wanted to be the age I was, but older.  Even as I passed what most people consider the milestone ages; 16, 18, 21, I just wanted to be over 30.  Now I’m not saying 30 is old, quite the opposite these days, it tends to be when most individuals in our country begin to hit their stride.

What’s humorous to me now about the pending 30 is that, I’m not really sure why I ever cared?  My age since 25 (lower insurance premiums, yes) has been a number, and of no value to me.  The thing I see now, in looking back, is God’s grace in getting me here.  I can’t boast in anything I’ve done, I am merely a vessel.  With that, I can’t help but approach this milestone age with some regret that it took me over 26 years to find what I have now, not what I’ve established materially, but spiritually.  I’ve an eternal legacy that’s been building now for 4 years.  That’s infinitely more exciting to me than my born on date passing a 30 year mark. 

To so many people that sounds so foreign and I’m sure a little nuts.  If you are one of those people, I ask you this: What’s your legacy look like?  Surely you feel that desire to be, more?  Why is that?

Now, it’s time to evaluate PowerShell.  As of late, PowerShell has become my preferred method for scripting.  PowerShell is built on top of the .NET framework.  It uses cmd-lets (commandlets) to perform the majority of it’s command line actions.  It’s also fully integrated with WMI and the .NET Framework.  It works off of Objects, which we discussed previously with VBScript.  It shares a lot of similarities to the BASH Shell, but the object based pipe is one of the more powerful features.  Objects in the pipe remain objects through to output.  This is an important element to remember if you are already familiar to the BASH shell and find yourself working in a Windows environment now (such as myself).

There’s a lot of good reading over what PowerShell is, so I’ll go ahead and start with our code and break it down as we’ve done in the past.  We’ll be introducing CASE statements this time around, as well as arguments.  I hope you enjoy it.

 Function Get-PowerShell {

The purpose of this script is to start, stop, or restart services on a single machine or list of machines read from a file.


#Service State Changer Script
#Author: Daniel Belcher

#Syntax:
#    .\set-remoteservice.ps1 stop spooler laptopname

PARAM([string]$STATE,[string]$SERVICE,[string]$TARGET)
$ErrorActionPreference = "silentlycontinue"
Function Set-RemoteService{
SWITCH($STATE){
        "Start"
            {$SET.Start()
                Write-Output "`nService: $($SERVICE.ToUpper()) `nStatus: Starting`n"}
       "Stop"
            {$SET.Stop()
                Write-Output "`nService: $($SERVICE.ToUpper()) `nStatus: Stopping`n"}
        "Restart"
            {$SET.Stop()
        Start-Sleep -Seconds 1
             $SET.Start()
                 Write-Output "`nService: $($SERVICE.ToUpper()) `nStatus: Restarting`n"}
             }

if ($STATE -ne "Start"){if  ($STATE -ne "Stop"){if ($STATE -ne "Restart"){
    Write-Output = "Invalid service state entered`n";Break}}}

                         }
if ($SERVICE -eq "")
    {$SERVICE = Read-Host "Please enter a valid service name"}
    if ($STATE -eq "")
        {$STATE = Read-Host "You need a valid state entry. Start, Stop, or Restart"}
        if ($TARGET -eq "")
            {$TARGET = $ENV:COMPUTERNAME}       
    $FILECHECK = Test-Path $TARGET
        if ($FILECHECK -eq $TRUE){
            $READ = gc $TARGET
                ForEach ($ITEM in $READ)     {
            $PING = gwmi -Query "select * from Win32_PingStatus where Address=’$ITEM’"
    if ($PING.StatusCode -ne 0)
        {Write-Output “$ITEM not found online, or invalid hostname.`n"}
    else
        {$SET = (Get-Service $SERVICE -ComputerName $ITEM)
                        Set-RemoteService
                    Start-Sleep -Seconds 1   
 
$STATUS = (Get-Service $SERVICE.ToUpper() -ComputerName $ITEM.ToUpper()).Status
         Write-Output = "Machine: $ITEM`nService: $SERVICE`nStatus: $STATUS`n"
}
                                }
                            }   
        else
            {$PING = gwmi -Query "select * from Win32_PingStatus where Address=’$TARGET’"
    if ($PING.StatusCode -ne 0)
        {Write-Output "$TARGET not found online, or invalid hostname.";
                            break}
            $SET = (Get-Service $SERVICE -ComputerName $TARGET)
                        Set-RemoteService
                Start-Sleep -Seconds 1  

$STATUS = (Get-Service $SERVICE.ToUpper() -ComputerName $TARGET.ToUpper()).Status
        Write-Output = "Machine: $TARGET`nService: $SERVICE`nStatus: $STATUS`n"
}


Copy and paste the above code and save it as a .ps1 which is the standard file extension for PowerShell scripts.  Now, lets set our execution settings from the PowerShell command line:

Set-ExecutionPolicy unrestricted

You can now execute the script by right-clicking and run with PowerShell, or by launching it from within the shell by navigating to it’s directory and typing it’s name.

Now lets look at our interest areas:

  1. Sequence
  2. Command usage
  3. Output usage
  4. Conditional logic

Sequence:

Sequence inside PowerShell is as expected.  It’s all run inline, and requires everything called to be defined before it’s call.  Looking at the above code you will see that we call Set-RemoteService two times, and we’ve defined it at the beginning of the script.  In VBScript, or in Command, calling a sub, function, or a GOTO statement will find the appropriate section and run that code.  So being aware of how your scripts process instructions is very important to their functionality.

Now for something new, arguments.  Arguments are, more or less, are user defined variables.  They are dynamic, and as such, need to be controlled to some degree.  So a fair amount of the script sequence is spent insuring that the variables passed are useable.  With PowerShell you are capable of defining the variable type.  This gives you incredible control and removes one more potential for unforeseen errors.

PARAM([string]$STATE,[string]$SERVICE,[string]$TARGET)

As you can see, with the PARAM statement we are opening 3 variables for input.  They are $STATE, $SERVICE, $TARGET.  We are also insuring whatever is entered is a string value.  So that leaves us with 2 issues.  The user needs to enter something, and it needs to be useable.  We will discuss this more in our conditional logic.

Command usage:

As we discussed at the beginning, PowerShell uses cmd-lets for the majority of it’s work.  It also allows you to call WMI and .NET methods and functions.  So similarly to to VBScript we can instantiate them for additional functionality.  The possibilities are plain astounding, and well beyond scope for this blog post.

Output usage:

Same as with our previous entries, all the work done is aimed at getting an appropriate output.  As such, capturing, reading, and modifying the output of all our commands is important.  How PowerShell does this, is similar to both VBScript and BASH.  You can pipe for output as input for other commands as well allowing for some very elegant one liner solutions.

Since PowerShell keeps everything in the pipe an object, your variables become immensely powerful since they are more than just stored returns from commands, but instead stored objects with invoke able methods, or property lookup, etc.  Lets evaluate how this works quickly:

$SET = (Get-Service $SERVICE -ComputerName $TARGET)

Here we are using a Get-Service Cmd-Let to grab a specific service, on a specific machine.  Now the variable service we are grabbing will have certain native METHODS and PROPERTIES we can leverage to either invoke or pull data.  What we need to understand is that the $SET variable is now an Object, not a Value.

$SET.Start()

Start and Stop are two methods belonging to Win32_Service objects.  So what we are doing here is saying essentially:

$SERVICE object, Invoke Method Start

So everything you see at the above link is now callable, or retrievable through this variable.  Pretty cool huh?  One thing of note, if you invoke a method that changes the state of an object, it’s properties will not be refreshed until it is called again.  You will notice in the code I declare a $STATUS variable.

$STATUS = (Get-Service $SERVICE.ToUpper() -ComputerName $TARGET.ToUpper()).Status

Because the state is changed, the property Status is changed.  Hence I couldn’t just recycle $SET with the $SET.Status.  The object needs to be refreshed. (Don’t be confused by the .ToUpper(), these are just native PowerShell methods for string management.  In this case UpperCase)

Now the $STATUS variable could just be considered a value.  Since it is in fact a capture of the property value.  Starting to make better sense now?

I don’t really utilize any direct error handling inside this script outside of the $erroractionpreference value.

$ErrorActionPreference = "silentlycontinue"

This just means if I hit an error, move on to the next statement, and do so without any visible output to the user.

Conditional logic:

We’ve discussed if statements before, and as promised, I offer you a practical case statement:

SWITCH($STATE){
"Start"
{$SET.Start()
Write-Output "`nService: $($SERVICE.ToUpper()) `nStatus: Starting"}
"Stop"
{$SET.Stop()
Write-Output "`nService: $($SERVICE.ToUpper()) `nStatus: Stopping"}
"Restart"
{$SET.Stop()
Start-Sleep -Seconds 1
$SET.Start()
Write-Output "`nService: $($SERVICE.ToUpper()) `nStatus: Restarting"}
}

The syntax says switch, but the methodology is the same.  All that is happening is we are saying if $STATE = “Start” or “Stop” or “Restart” do this.  Either 3 separate if statements, or 1 case statement.  Fairly efficient manner for handling complex conditions that hinge around one variable.

So what does this PowerShell script do?

It begins by declaring 3 variables that are to be string values.

Then it tells the shell to remain silent and continue on errors.

Next it builds a function to be reused through the remainder of the script

Function Set-RemoteService{

This is where our case statement is built and stored.  We also have an additional conditional statement in there to insure that one of the 3 pre-defined strings were typed correctly.  Now we perform an if statement to determine that the variables were defined at execution, if not then we prompt the user for input.  If $TARGET is empty we simply define it as $ENV:COMPUTERNAME, which is equivalent to LOCALHOST (just a bit more elegant).

Now it performs a quick check to determine if the $TARGET passed was a file or simply a name.  If it was a file, the file is opened and assigned to the $READ variable where a for each statement is run against it.

A $PING test is done using a WQL to determine if the machine is online, or if the name is even valid.  (the reason we do this, is that it’s increasingly faster to ping for response than to wait for a timeout to occur on a RPC request).

If the machine successfully pings it moves on to declare the $SET variable object for use in the Set-RemoteService function.  Then it executes the function, then a 1 second pause, and then builds an object property variable that is used in a console message to the user notifying them the state of the service after the action.

If it wasn’t a file, it does the same thing without a ForEach statement.

}


So you want a little more?

I’m going to quickly show you how you can integrate this script, into a profile function.  It’s exceptionally easy, and I recommend it for scripts you’ve built that you find invaluable for day to day use.

Here goes the modified code:

Function Set-RemoteService {
PARAM([string]$STATE,[string]$SERVICE,[string]$TARGET)
$ErrorActionPreference = "silentlycontinue"
Function SRS{
SWITCH($STATE){
                       "Start"
                           {$SET.Start()
                                  Write-Output "`nService: $($SERVICE.ToUpper()) `nStatus: Starting`n"}
                       "Stop"
                           {$SET.Stop()
                                  Write-Output "`nService: $($SERVICE.ToUpper()) `nStatus: Stopping`n"}
                       "Restart"
                           {$SET.Stop()
                     Start-Sleep -Seconds 1
                            $SET.Start()
                                  Write-Output "`nService: $($SERVICE.ToUpper()) `nStatus: Restarting`n"}
                           }

if ($STATE -ne "Start"){if ($STATE -ne "Stop"){if ($STATE -ne "Restart"){
      Write-Output = "Invalid service state entered`n";Break}}}

                          }
if ($SERVICE -eq "")
    {$SERVICE = Read-Host "Please enter a valid service name"}
    if ($STATE -eq "")
        {$STATE = Read-Host "You need a valid state entry. Start, Stop, or Restart"}
       if ($TARGET -eq "")
           {$TARGET = $ENV:COMPUTERNAME
      $FILECHECK = Test-Path $TARGET
             if ($FILECHECK -eq $TRUE){
                 $READ = gc $TARGET
                           ForEach ($ITEM in $READ) {
           $PING = gwmi -Query "select * from Win32_PingStatus where Address=’$ITEM’"
    if ($PING.StatusCode -ne 0)
       {Write-Output “$ITEM not found online, or invalid hostname.`n"}
   else
       {$SET = (Get-Service $SERVICE -ComputerName $ITEM)
                              SRS
                          Start-Sleep -Seconds 1
$STATUS = (Get-Service $SERVICE.ToUpper() -ComputerName $ITEM.ToUpper()).Status
             Write-Output = "Machine: $ITEM`nService: $SERVICE`nStatus: $STATUS`n"
}
                                                       }
                                               }
             else
                   {$PING = gwmi -Query "select * from Win32_PingStatus where Address=’$TARGET’"
         if ($PING.StatusCode -ne 0)
              {Write-Output "$TARGET not found online, or invalid hostname.";
                                                  break}
                    $SET = (Get-Service $SERVICE -ComputerName $TARGET)
                                   SRS
                        Start-Sleep -Seconds 1

$STATUS = (Get-Service $SERVICE.ToUpper() -ComputerName $TARGET.ToUpper()).Status
             Write-Output = "Machine: $TARGET`nService: $SERVICE`nStatus: $STATUS`n"
}

}

We’ve enclosed the entire thing into a Function statement now, and redefined the internal function.  The reason for this was, well, I prefer to stick with cmd-let naming patterns.  I’d rather call set-remoteservice at the command line.

Now, we need to build our profile, from inside PowerShell, at the command line type:

notepad.exe $PROFILE

Now paste the above code and save it.  If you are inside ISE press F5 to run the script and update your profile, or if you are in the standard shell type:

powershell

This will start a new shell instance inside your previous shell with the updated profile.

Be mindful, PowerShell and PowerShell ISE have two separate profiles.  So if you perform this in ISE the standard shell won’t receive the update and vice versa.


That does it for my stick to the script series.  I hope you’ve learned a lot regarding scripts through this and it’s shed some light onto what scripting is and de-mystified it for you.

I will continue to post scripts for various things over time, as well as neat tricks as I learn them so I wouldn’t say this is truly the end. 

Editors:

If you intend to do a lot of scripting, I recommend you grab yourself a steady editor.  Preferably one with configurable highlighters.  Below are a list of a few free and premium editors I recommend.  I’ll start with the freebies:

  • Context – A nice, windows based, free editor (my usual windows editor). Configurable highlighters, comparison tool, and configurable execution keys.  All the basic needs of a script writer.  Minus integrated libraries.  I believe development has all but stopped since 09, so this might not be the best editor to stick to.
  • Emacs – Extremely powerful development environment built for OSS, but with Windows versions.  This is more than a simple editor, it’s a Swiss army knife.  It will require a bit of a learning curve to begin using it but is worth it in the end.
  • VIM – My preferred editor in Linux, switchable modes, highlighters, line numbers, split views, compares, command line style editing.  Like emacs, it’s extremely powerful, and has a bit of a learning curve.  I prefer VIM, but Emacs is far more extensible, just fyi.
  • NotePad++ – A really nice OSS editor for Windows.  I should probably start using this over Context, but I’ve already spent so much time with Context configuring it, I’ve become extremely comfortable with it.  I’d recommend this editor to any novice windows scripter.
  • PowerGUI – Both a free, and paid edition.  I recommend this editor for PowerShell whole heartedly because of it’s syntax and object recognition tools.  If you are going to do a lot of work with PowerShell, I recommend using this editor for it.
  • PSEdit – Included with the PowerShell ISE.  It’s the standard PowerShell editor.

Premium:

If you are interested in learning more:

Stick to the Script Parts 1 – 4:

  1. Stick to the Script…
  2. Stick to the script #!/BIN/BASH…
  3. Stick to the script CreateObject(“Wscript.Shell”)…
  4. Stick to the Script PS C:\> PowerShell …

I’ve honestly been trying to post my final part to the “stick to the script” series.  However those actions have been soundly thwarted by an abundance of work, and a new workout regiment.  I hope to have it up and syndicated to myitforum before the weekend is over.

I’ve also built a nice sccm client install script, and thanks to John Marcum, I’ve built a nice remote cm wmi repair tool in powershell as well.

So stay tuned as I plan to start releasing those scripts after scrubbing them.

Three years and five months ago we welcomed a beautiful little boy into this world.  I finally met him, but you knew him for at least 4 years and 2 months, effectively giving you two a 9 month lead on daddy.

will and mommy

And 8 months ago we welcomed in a beautiful sign of God’s grace and mercy into our life with our baby girl.  You’ve known her 1 year and 5 months, again a 9 month lead.

2011-02-08_08-19-10_279

You know our children, you love, in abundance, our children.  You carry on for them when I would break from the strain and you do it time and again.  You help me to keep them in and aware of the word of God and you intercede, respectfully, on behalf of our children when they need it.

2011-05-07_18-54-37_952

You love our God, and your role as a steward to our children so much that you have gladly abandoned what the world demands of a you.  Refusing to allow any inappropriate secondary influences take precedence in our children’s lives.  You inspire me to be a better father, as you inspire me to be a better husband, which inspires me to be a better man and Christian.

You care for me with a love and a heart that is greater than you even have for our children, and for that I give glory to God.  Our children don’t know it now, but one day they will realize how amazing their Mother is, and see her Father reflected in her.  In that way, they could have no better mother.

Happy mothers day baby.

 

2011-05-07_10-08-59_812

Here I am riding to find your present mommy!

2011-05-07_11-16-11_276

Here I am holding your presents from me my mommy!

And uh, this may not make sense yet, but it will.

shipped

I love you.