The Energized Tech

*** WARNING! ***
*** This Blog Post will talk about Developer Terms ***
*** ItPros are cautioned to break out their (Patent Pending) ***
*** “Peril Sensitive Sunglasses” (Ala the HitchHikers’ Guide to the Galaxy) ***
*** Before Reading further. If you are amongst the Bold and the DARING and the ***
*** Truly Devil May Care of ITPros, Please feel free to Read on and live Daring! ***

But don’t say I didn’t warn you :)
Sean – The Energized Tech

Today my fellow ITPros, we are going to step OUT of our element and do something SO scary, you must just throw your Fluke meters away in Disgust.  

Yes, we’re going to use a METHOD!

Over the next while, we’re going to learn a LOT of “Methods”, and ye Lords of COBOL willing; you will ENJOY it.

Funny words aside, we’re going to little by little show you some of the Methods available in Powershell and perhaps get you a little bit used to digging into the land that Developers live in.

Today’s Method is brought to you by the letter “S”.  It is “substring()”

Substring() is a function if you would that lets you pull out pieces of a Cha……

“Zzzzzzzzz Gzaaawwwww..Snort snort..”

“You in the back, WAKE UP!” *WHAP*

I can always spot a snoozing ItPro when I’m talking out of their scope. So let’s keep this simple.

You have a String, Text information.  You need a PIECE of it.   Substring() is one of the Methods available to you to do just that.   Nice and simple as well.

If assign a small word say…

$Word=’SuperCaliFragilIsticExpiAliDocious’

To a variable and run that through a GET-MEMBER I get

These all all the Members of object $Word.  As you can see we have a Method call Substring().   To access a Method is almost just like accessing a Property.  Simply typing a “.” between the Object “$Word” and the name of the Method you want to apply to the Object “SubString()”

So we just type in…

$Word.Substring()

And yaaayyy it just….

It just immediately gave us a big Wawa error

That’s because many methods require additional parameters, information to know what you WANT them to do.  Some don’t.

To get an Indication what your Method “Substring()” wants you can have Powershell TELL you.  The very same GET-MEMBER we ran before can be used to just tell us about “Substring()” (or any other Method for that matter)

Just add on –Name and the name of Method after a ‘GET-MEMBER’, then pipe it through FORMAT-LIST to see all the details.  Look for “Definition”

What this definition translates to is it wants the parameter in one of two ways.

The first one

string Substring(int startIndex)

Says “I want you to put an INTeger in here (a number) saying WHERE to start”

So if we do

$Word.substring(10)

(remembering our Word was ’SuperCaliFragilIsticExpiAliDocious’) we will get the Variable $Word starting at position 10 of the character array and all the rest)

agilIsticExpiAliDocious

Will be what we see

and if you do a

$Word.substring(25)

Your results will be

liDocious

Since it starts in by 25 characters. And now it gets fun.  The OTHER definition of substring() was

string Substring(int startIndex, int length)

This translates to Says “I want you to put an INTeger in here (a number) saying WHERE to start, then I want another INTeger (num……

“…Ggggggznnnzznznnn……Zzzzzzzzz Snrt..”

Excuse me for a minute.

***PPPPHHHWWWWWAAAAAPPPP!!!***

…Ahem, nobody sleeps in my Blog.

So as I was saying This translates to Says “I want you to put an INTeger in here (a number) saying WHERE to start, then I want another INTeger (number again) saying how MUCH to show from that point forward.

So with the name $Word we can now do this

$Word.Substring(5,4)

will show us

Cali

Since that part of the string is 5(Five) letters in and we’re showing 4(Four) from that position forward.  Or I can do a

$Word.substring(24,6)

Which will show us

AliDoc

Because again, it’s going in 24(Twenty-Four) characters, and displaying the next 6(Six)

The thing is, once you understand a LITTLE about one Method, it’s not TOO horribly difficult to pick up on some of the rest.

You may now return to your regularly scheduled channel and Remove the Peril Sensitive Sunglasses.  And Sleepy from the back can go back to work. :)

Sean
The Energized Tech

*** WARNING! ***
*** This Blog Post will talk about Developer Terms ***
*** ItPros are cautioned to break out their (Patent Pending) ***
*** “Peril Sensitive Sunglasses” (Ala the HitchHikers’ Guide to the Galaxy) before ***
*** Reading further.   If you are amongst the Bold and the DARING and the ***
*** Truly Devil May Care of ITPros, Please feel free to Read on and live Daring! ***

But don’t say I didn’t warn you :)
Sean – The Energized Tech

One of the things ITPros need to understand about Powershell is it’s ALL ABOUT OBJECTS!

Unlike many scripting languages that deal with Absolutes like “Arrrays” and “Strings” and “Numbers” Powershell is about as “Grey” (Or really Blue) as you can get.

I’m not going to pretend to understand all the deep spiritualness of Objects and OOP.   Most days I’m lucky if I don’t kick the LAN cable out of the wall socket or don’t fall off my own seat.   I’m an ITPro but first off I’m a disorganized Boob.

And OOP and Objects are very organized.  

In the old world of Dos you had a simple thing called a Variable.

%PATH%=C:\DOS\BATMAN

We all know what that is.  Just a String.  Letters.  Simple.

Or Is it?

Look at it.  We all know that it’s pointing to a Directory.  And that Directories contain files.   And that the files in the Directory are stored in a certain format (8.3) or LongFilename.    We know that in particular that Directory is probably full of Batch files (Ok I’m guessing, It really could be full of TunaFish)

But my point is simple.   We have just described an Object.

An Object is REALLY a Variable like we used to think, but a lot more (or sometimes a little) more descriptive. It says what information it has (Properties) or what we can DO to it (Methods).  There are sometimes even Multiple Properties (like the Foldername, the date it was created on) and different Methods like Delete folder, Rename.  There are many aspects to an Object.

But as ITPros we don’t need to be Experts on Objects to work with Powershell. We just need to have a little understanding of what they are.   And accept that Powershell is actually passing, reading, writing, examining nothing but Objects.

Sometimes we look at piece of an Object (like the Filename from a File) or we deal with the Whole Object (A Directory Structure)

When you pipe a Commandlet into a GET-MEMBER, all you’re doing is saying “Show me all the pieces attached to this Object I can look, play or work with”

That’s it.

Here’s an example of simple Object, a Directory.  When you type in

GET-ITEM C:\Powershell

You will get this message (Presuming you have a folder called “Powershell” at the root of your C: Drive

And as always we can store that away in a Variable in Powershell.   But it’s NOT a directory we’re looking at.  It’s an OBJECT. 

$JustAnObject=GET-ITEM C:\Powershell

When you run that Object through a GET-MEMBER you’ll see the various Properties and Methods attached to that Object, like so

Although it gives us a large pile of goodies, most of the time we only see the Name (Name of the Directory), the Attributes (Read only, Archive etc) and the CreationTime.

But knowing there is MORE there if you need is part of the understanding of an Object.   Understanding that it is Vague enough that just about every Powershell Commandlet will look at an OBJECT and work with just the pieces that it needs or understands is the Important bit.

And knowing that you can take out and use only the pieces you need AS you need them is half the battle.

You may now remove your “Peril Sensitive Sunglasses”, ITPros are safe to step back to normality and chewing on LAN Cables ;)

Sean
The Energized Tech

After July 13th 2010, Windows XP SP2 and Vista RTM will no longer be supported by Microsoft.  This means making sure your systems are at LEAST running Windows XP SP3 or Vista SP1.

But for you the ITPro, you need to quickly and EASILY know which machines need the update.

And for this, Powershell is your friend and greatest ally.

All you have to execute is a simple WMI Commandlet

GET-WMIOBJECT win32_operatingsystem

This ONE little Commandlet will tell us almost ANYTHING we need to know about that version of Windows on a computer.  SKU, LicenseKey and more importantly Name and Service Pack of the software.   Again piping this through a GET-MEMBER will tell us what properties are there.  There are Three we are interested in

NAME
ServicePackMajorVersion
ServicePackMinorVersion

So if you select those objects like so

GET-WMIOBJECT win32_operatingsystem | SELECT-OBJECT Name,ServicePackMajorVersion,ServicePackMinorVersion

You’ll have the details for your local computer.   Now if you execute that with the parameter computername and the name of a remote Workstation (presuming WMI is enabled)

GET-WMIOBJECT win32_operatingsystem –computername SOMECOMPUTEROVERTHERE | SELECT-OBJECT Name,ServicePackMajorVersion,ServicePackMinorVersion

You can pull up the details remotely for any computer.   And now if you have a LIST of computers ready (Let’s try a list from Active Directory, pulled from Quest)

GET-QADCOMPUTER | foreach ( GET-WMIOBJECT win32_operatingsystem –computername $_.Name | SELECT-OBJECT Name,ServicePackMajorVersion,ServicePackMinorVersion )

Now all your work is done.  You can easily determine which machines need the Service Pack or in some cases, need to be upgraded to a newer O/S!

All thanks to a free utility called Powershell, and my closest friend :)

Sean
The Energized Tech

This Saturday in Downtown Toronto is a free event called Toronto Sharepoint Camp.

It’s Free and for the Developer Community, but honestly if you’re the least bit curious about Sharepoint on some level (especially with Sharepoint 2010 being released soon) I would check it out.

All details about the event are here and for Registration.

It’s located at

Manulife Financial Corporation
200 Bloor Street East
Toronto, Ontario
M4W 1E5

Click Here for Map

On Saturday March 20th 2010

Seek the innerpoint Sharepoint guru in you and gather to learn.

Oh and by the way… It’s absolutely FREE (Other than bringing $5 to buy a lunch)

Sean
The Energized Tech

Last time we saw that you can pull out Processes using GET-WMIOBJECT as well as GET-PROCESS

This time we’re going to show you WHY you should use GET-WMIOBJECT.  

Again the strength of GET-PROCESS is it’s simplicity.  That’s also it’s weakness.    GET-WMIOBJECT is a little more complex to work with but like all great tools, it has it’s place.  Here is one.

We can isolate WHO owns a process using GET-WMIOBJECT.  It takes a small Script to do it but it works well.  Each Process you access with GET-WMIOBJECT win32_process has a Method called GETOWNER()

To find the owner of a process we Get the process, and run a GETOWNER() on the process.

So with our Present Function we can modify it to list those Process Names, IDs and now the OWNER.

Function GLOBAL:GET-PROCESSUSER ( $ProcessName, $Computername ) {

(GET-WMIOBJECT win32_process –computername $Computername –filter “Name=$ProcessName”).GetOwner()

}

So now with this little function we have a VERY easy way to identify who is running a particular process on any computer in our network. 

And knowing who and what makes the next step, Killing that process; incredibly easy.

Sean
The Energized Tech

One of the beautiful things about Powershell is how it so EASILY leverages WMI.   It extends your administrative abilities so easily.

In the forums somebody was asking some very specific questions about terminating processes and it dawned on me that the GET-PROCESS Commandlet, although easy to use and Powerful, didn’t actually list WHO owned the Process.

Why do you care about that?  On a single workstation you might not.   But in a Terminal environment where you need to selectively terminate applications based either upon the APP itself or if a SPECIFIC USER is using an App.  Then you get a bit more granular.    But all of this is available via WMI.

And do you know who told me this?  The HELP GET-PROCESS –Detailed option

In trying to determine how to pull up the owner, the very documentation within GET-PROCESS says to use

$p=GET-WMI-OBJECT win32_process –filter “Name=’powershell.exe’”
$p.getowner()

as an Example.

So in playing with this Commandlet I found (By running a GET-MEMBER on the results) it has a “Terminate()” method as well.   And being that WMI-OBJECT also has a –computername parameter two pieces came together.

One, I can access the list of running processes with a UNIQUE process ID for each one as well as WHO is running them.  Meaning I can be VERY specific *OR* Very broad as I choose in terminating a Task.

So in running the following line

GET-WMIOBJECT win32_process –computername WRKSTATION01

I can access all tasks running on that workstation

GET-WMIOBJECT win32_process –computername –filter “Name=’IEXPLORE’”

And we can write this in a function easily too.

Function GLOBAL:GET-PROCESSUSER ( $ProcessName, $Computername ) {

GET-WMIOBJECT win32_process –computername $Computername –filter “Name=$ProcessName”

}

But so far we really haven’t done anything amazing.  This seems SO far to just be another badly done version of “GET-PROCESS” with more typing.

And for the MOMENT, you’re correct.  Which is where next time we’re going to see how to add in a User Filter to that list.

Powershell, fire up the Scripter in you

Sean
The Energized Tech

So you want to modify some attributes in the Exchange 2007 Send connector but you hate using ADSIEdit?

In all fairness, 90% of what we need to change is inside Powershell already for Exchange 2007.  But there are new Commandlets in Exchange 2010 that improve how you can limit to inbound / outbound mailflow.   

Many of those are a available in Exchange 2007 with Service Pack 2, but there is no Easy Safe way to change them.  One of these settings I blogged about last night which is “MaxMessagesPerConnection”.  Changing this normally involves using ADSIEdit, which is doable, but ADSIEdit is a VERY powerful tool and as such, a bit dangerous if you hit “Delete” in the wrong spot.

So I decided to port this to a Function, and make this easier to work with.

You can access ANYTHING in Active Directory so long as you know it’s “DistinguishedName”.  Every object in Active Directory has one, you’ll recognize it by the sequence.

CN=User,CN=Folder,OU=Users,DC=Domain,DC=local 

Remember that.  EVERY SINGLE OBJECT in Active Directory has it.  And knowing that makes all of this easier.  

So first off, this attributte is component of your SEND Connector in Exchange.  Using GET-SENDCONNECTOR you can pull up your list

If the SendConnector was named “Mail to Internet Relay” or “Windows SBS Outbound Mail” better yet you key in

GET-SENDCONNECTOR ‘Windows SBS Outbound Mail’

and that you give you your Send-Connector properties.  But all we want is the Distinguished Name.  We can get that using a SELECT-OBJECT and store the results away in a Variable.

$CONNECTOR=GET-SENDCONNECTOR ‘Windows SBS Outbound Mail’ | Select-OBJECT DistinguishedName

Now we have the “Distinguished Name” for your SMTP Send Connector (or the one name “Windows SBS Outbound Mail”)

So we now pull out the String part of that object called “DistinguishedName” and store it away for the LDAP query.

$Name=CONNECTOR.DistinguishedName

To Query and work with Anything in Active Directory that does not have a prebuilt Commandlet like Quest ActiveRoles or Active Directory Modules, we use the [ADSI] Accelerator.  All we do is Plug the Distinguished Name in to look at THAT object and work with it.

$SMTPCONNECTOR=[ADSI]”LDAP://$Name”

We can now open the hood and access ALL of the attributes of the SMTPConnector.  Just pipe the $SMTPCONNECTOR through GET-MEMBER like this

$SMTPCONNECTOR | Get-member

If you are running Exchange 2007 SP2, there is a new Attribute called “msExchSmtpMaxMessagesPerConnection”.  To access the value of that (or any other new attribute) but tack it onto the $SENDCONNECTOR variable to see it’s value

$SMTPCONNECTOR.msExchSmtpMaxMessagesPerConnection

Simply by assigning this with a value of say 1 or 2, (Adjust to suit your needs) will LIMIT outbound to one or two per SMTP session (unlike default which is send a lot and hope the SmartHost will accept it)

$SMTPCONNECTOR.msExchSmtpMaxMessagesPerConnection=1

Then once done, you update Active Directory with the new Connector settings.

$SMTPCONNECTOR.CommitChanges()

So what would all of that look like as a script?  Glad you asked, only about 3 lines really.  Take a look.

---------- Set

GET-SENDCONNECTOR ‘Windows SBS Outbound Mail’
$Name=CONNECTOR.DistinguishedName
$SMTPCONNECTOR=[ADSI]”LDAP://$Name”
$SMTPCONNECTOR.msExchSmtpMaxMessagesPerConnection=1
$SMTPCONNECTOR.CommitChanges()

But even nicer?  I can make this whole thing a function and add it to my Powershell Profile for daily use as a new Commandlet!

function global:SET-SENDCONNECTORMAXMESSAGE ( $NameOfConnector ) {

# Limit is the number of outbound messages to allow PER connection to SMTP Smarthost.
# 1 is very controlled.  The higher the number, the more messages you are able to send
# in a single shot, the greater the likelyhood you are treated a spammer.
$limit=1

GET-SENDCONNECTOR $NameOfConnector
$Name=CONNECTOR.DistinguishedName
$SMTPCONNECTOR=[ADSI]”LDAP://$Name”
$SMTPCONNECTOR.msExchSmtpMaxMessagesPerConnection=$limit
$SMTPCONNECTOR.CommitChanges()
}

So if you are running SBS 2008 (Small Business Server 2008) and have to deal with a SmartHost and their mail restrictions, update to Service Pack 2 of Exchange 2007 and work with this attribute.  It is the Holy Grail that you seek.

And make sure you thank Rick Lund-Pedersen of Around the Clock I.T. Solutions for sending me down the path to write this script. :)

Sean
The Energized Tech

Had a call today from a user that had to pull up a file.  The file wasn’t LOST but it was a IMPORTANT and of course they had no clue what the file was called.  Just that it was a Word document.

Well normally, as an Administrator or an ITPro you’d put your hands in the air and go “BLAH!” because pulling out an obscure file WITHIN a file system only know what day of the week it may have been opened with an obscure Window of information to search with was a TRUE impossibility. 

Two options, tell the user to go fly a kite or find some custom software.

I lied.  There’s a third VERY viable option.  Powershell.

Here’s a PERFECT example of how you can use Powershell to mine through the file system without heavy effort.

Ok first off let’s pretend we have the following information to work with.

• The File is a Word document.
• It was created about a Month Ago
• It was created on a Thursday or a Friday (User is not sure)
• And they’re PRETTY certain it was created between 10:00pm and 2:00pm

And you wonder why ITPros bang their head on a desk.  Normally THIS is a “Nope.  Not doin’ it, go find a dev, go explain to your boss, not my problem, fergettaboutit!”

But in Powershell this is all a NON issue

First off let also pretend I at least know what folder structure it’s in.  There’s only a million files inside \\CONTOSO\BIGfileShare so this shouldn’t take long.

Filtering by file type?  That part is easy.  That’s an option in GET-CHILDITEM

GET-CHILDITEM –recurse –include *.DOC \\CONTOSO\BIGfileShare

Now to make things easier, we don’t want to keep querying against the file system over and over and over.  So let’s store those objects away

$FILELIST=GET-CHILDITEM –recurse –include *.DOC \\CONTOSO\BIGfileShare

Now we can examine the data more quickly.  So let’s isolate that list of files Modified between 30 to 45 days ago.  We can do that easily by comparing the date files

$TODAY=GET-DATE

$FILELIST | where { ($_.LastWriteTime –gt $Today.AddDays(-45)) –and ($_.LastWriteTime –lt $Today.AddDays(-30)) }

And now to show only files modified between 10:00am and 2:00pm over that time Frame.  We can access the HOUR or MINUTES in any [DATETIME] field by accessing that specific property and comparing with it numerically.

$FILELIST | where { ($_.LastWriteTime –gt $Today.AddDays(-45)) –and ($_.LastWriteTime –lt $Today.AddDays(-30)) –and ($_.LastWriteTime.Hour –gt 10) –and ($_.LastWriteTime.Hour –lt 14) }

But still ---- “I did this on a Thursday or Friday” that most maddening piece.

Everywhere else?  Headache.  Powershell?  PIECE OF CAKE

We can actually pull out the DAY of the WEEK in ANY date in Powershell.  And yes even in a File creation date or time.  It actually shows up as the REAL name of the day!

$FILELIST | where { ($_.LastWriteTime –gt $Today.AddDays(-45)) –and ($_.LastWriteTime –lt $Today.AddDays(-30)) –and ($_.LastWriteTime.Hour –gt 10) –and ($_.LastWriteTime.Hour –lt 14) –and ( ($_.LastWriteTime.DayofWeek –eq ‘Thursday’) –or ($_.LastWriteTime.DayofWeek –eq ‘Friday’)) }

All in all when you look at that line you may just say “WHAAAATTT??!!” and walk away.  But let’s break it down

$FILELIST | where {

($_.LastWriteTime –gt $Today.AddDays(-45)) 
–and
($_.LastWriteTime –lt $Today.AddDays(-30)) 
–and 
($_.LastWriteTime.Hour –gt 10) 
–and
($_.LastWriteTime.Hour –lt 14) 
–and
( ($_.LastWriteTime.DayofWeek –eq ‘Thursday’) –or ($_.LastWriteTime.DayofWeek –eq ‘Friday’))

}

When you take a look all we are doing is examining ONE field, the “LastWriteTime”.   There are multiple properties in that field we can examine and we can get VERY granular.    Even down to Minutes and the very MONTH something occurred on.

Who would have EVER thought you’d have that much Power to mine the file system!  And in checking?  You can just as EASILY Distributed File Systems with this command as well.

Powershell.  It’s not just for Breakfast anymore

Sean
The Energized Tech

A good friend of mine and the Owner of Around the Clock I.T. Solutions Inc., Rick Lund-Pedersen had a bit of a stumbler.   A throttling feature that existed in Exchange 2003 and DOES exist in Exchange 2010 (which a Powershell Commandlet to Boot!) was MISSING from Exchange 2007.

We called it “maxmessagesperconnection” .

It allows us ITPros to limit the amount of messages sent out in EACH connection to a destination SMTP server.   In the case of those who use a SmartHost you’ll find some of them actually limit the number of messages you can tranmit in a single connection to reject possible spam flow.

Which is where this feature (which used to sit on the Virtual SMTP Server settings in Exchange 2003) was so badly needed in SBS 2008 and other sites using a Single Exchange 2007 server setup.  Such environments have a 100% locked off firewall and send all outbound mail to a Smarthost and use a FAST but inexpensive High Speed internet.  This completely negates the need for expensive onsite hosting while still leveraging all the power that Exchange 2007 has to offer.

But alas.  Microsoft (or Somebody on the Exchange Team to be more correct) in the ten Billion lines of code, misplaced a feature. 

MaxMessagesPerConnection.  But now that error has been corrected.  Download and update your Exchange 2007 Server to Service Pack 2 and some new objects will be in the Schema This service pack is ALSO approved for SBS 2008.  When you go to run it, it will have you download a VERY specific update for SBS 2008 (it’s small) that will launch and integrate Service Pack 2 for Exchange 2007 PROPERLY for Small Business Server 2008.  Once done, some new schema changes and features are added to Exchange 2007.

Amongst them, MaxMessagesPerConnection.  Now it’s not in the GUI or Powershell until Exchange 2010 but it IS there to edit.  Which is all we want.  Fire up ADSI Editor (Free download or if you’re using Server 2008 it’s already a part of your Management tools)

**** At this point, if you are NOT comfortable with editing Active Directory, stop.  This truly gets ‘Under the Hood’ and an “accidental Delete” will mean a restore from Backup. ***  TAKE WARNING AND TAKE HEED AND DO NOT EDIT THIS LIGHTLY ****

Once in ADSI Edit you’ll need to change “Select a well known naming Convention” to Configuration once the console loads up.

Once in you’ll have to start digging through the tree starting from

Configuration (Expand and then choose)
CN=Configuration,DC=Domain,DC=local (Normally this is your domain which will have a different name under Domain and Local, Expand and then choose)
CN=Services (Expand and then choose)
CN=Microsoft Exchange (Expand and then choose)
CN=First Organization (Expand and then choose)
CN=Administrative Groups (Expand and then choose)
CN=Routing Groups (Expand and then choose)
CN=Exchange Routing Group (GibberishNumber) (This will be different for each site.  Then expand and then choose)
CN=Connections

In the Windows to the right you will see an Entry for each Send Connector you have.   Compare the names to the one you need to edit and double click that ONE.

Drill down until you find an entry called

msExchSmtpMaxMessagesPerConnection

Double click on it. It normally has no value and runs at Default settings (I don’t know the actual number, but it’s pretty unrestrictive)

Place a value from 1 or higher.  The Lower the number the fewer emails that are sent in a SINGLE SMTP CONNECTION to the Smarthost.  Click ok and close all of the Windows off.  Restart the Transport Service to ensure the new settings are picked up as well.

So if you have an ISP that restricts you to no more than say 30 emails in EACH SMTP connection (Exchange will send as many as you have be default) you’ll find either bad mail flow OR (most likely) you get dropped and have to explain yourself.  Embarassing and non productive.

With this change in, you have a way to keep outbound Mail flowing from Exchnage 2007 in a manner than keeps both YOU and the owner of the SmartHost happy.

And yes, I’m trying to write this into a Powershell script :)

And again, Exchange 2007 ONLY GETS THIS IN THE SCHEMA with SERVICE PACK 2 of Exchange Server 2007.

And again, a Special Thanks to Rick Lund-Pedersen of Around the Clock I.T. Solutions Inc for research into this issue and for finding the lost child.

Just keeping the mailflow on the go

Sean
The Energized Tech

I’ve never been a Fan of the Blackberry.  Just not a fan.

For what’s it meant to do, it’s good but I don’t like being locked down, I don’t like the lack of compatibility in it’s Browser.

It’s just not “ME”.

But I DO have to give some Kudos to the new Curve.  It’s what the entry level unit finally needed.  A good cleanup.

The present Curve sports the same newer “Look” as the Blackberry Bold.  Whether you like that or not is up to you, but it IS a fresher look.   They were also smart to NOT change the size of the Curve.  This means if you own one and upgrade, you don’t have to go scrambling for a new case.

It seems to be sporting a faster CPU and definitely responds nicer.  My particular model has Wifi which allows to cut down on the Data plan costs.   And finally, Finally, FINALLY somebody got a *CLUE* at Research in Motion to get RID of that STUPID mouse ball. 

How many users had to put up with THAT stupid idea based upon technology that was scrapped by the rest of the Industry ages ago?  How many people spent $50 to replace a 1/2 centimeter object that was ruined over and over by nothing other than a piece of FLUFF?!

Well the new Curve at least changed that, or more correctly; CAUGHT UP with the industry.   The Laser tracking is a much better mouse on the Curve.   The display appears brighter and moderately larger as well.   They also kept some legacy as well.  Same Battery and your memory card ALSO transfer over.

This is liked.

What they took away was the little light for the Video camera, which really didn’t matter.  The only time I used that was to stumble about my room in the morning as a “mini flashlight” (Call that an Undocumented Feature)

I’m still not a fan of the Blackberry as a whole, but this new model at least makes me feel less unhappy about using it.

Sean
the Energized Tech