Search results matching tag 'Personal'

A wee bit exhausted… time to reenergize

drsql — Tue, 11 Dec 2012 02:26:00 GMT

I admit it. I am tired and I have not blogged nearly enough. This has been a crazy year, with the book I finished writing, the pre-cons I have done (teaching is NOT my primary profession so I do a lot more prep than some others probably do), lots of training on Data Warehousing topics (from Ralph Kimball, Bob Becker, and Stacia Misner, to name three of the great teachers I have had), SQL Rally, SQL PASS, SQL Saturdays and I have gotten a lot more regular with my simple-talk blog as well… Add to this the fact that my daughter added a new grandchild to the family, and my mother has started to get so weak she is starting to fall down quite often (I am writing this blog entry from a spare bedroom at my mother-in-law’s house while my mom is in rehab!) and I am getting exhausted.

Am I whining? Probably, but it is my blog! No, seriously I figure that occasionally you have to poke your head out from under the covers and write something and this is my something until after the New Year (other than posting a few already written and edited simple-talk blogs). I am on vacation from work for 2.5 weeks, and I don’t plan to do much with this laptop of mine for those two weeks unless the spirit hits me with an idea for a blog that I just have to write, but usually most of my blogs that have any technical or artistic merit take weeks to complete. On the second of January, I hope to be back at it, analyzing my resolutions from last year, and making good on a few of them, particularly “Blog about my other (computer) love occasionally” and review some of the gadgets I have acquired as they pertain to doing my job as a writer/data architect. (Hint: My mother-in-law does not have Internet access, so some of the devices I have here are instrumental in my ability to work untethered for weeks on end.)

So until next year, Merry Christmas, Happy Holidays, Happy New Year! I hope your holidays are restful and fun. I know part of mine will be because I intend to replicate this picture at least one or two more times next week, hopefully with a Turkey Leg in the hand that isn’t holding the camera taking the picture (all with my Windows Phone set on Battery Saver Mode, which delightfully turns off all syncing :)

T-SQL User-Defined Functions: the good, the bad, and the ugly (part 1)

Hugo Kornelis — Sun, 20 May 2012 14:08:00 GMT

So you thought that encapsulating code in user-defined functions for easy reuse is a good idea? Think again!

SQL Server supports three types of user-defined functions. Only one of them qualifies as good. The other two – well, the title says it all, doesn’t it?

The bad: scalar functions

A scalar user-defined function (UDF) is very much like a stored procedure, except that it always returns a single value of a predefined data type – and because of that property, it isn’t invoked with an EXECUTE statement, but embedded in an expression where the returned value is immediately used. I won’t explain all the basics, but assume that you are either already familiar with the concept, or that you at least have read the description in Books Online. It is allowed to read (but not modify!) table data from within a scalar UDF, but in this blog posts I will focus on scalar UDFs that include computations and other expressions only, without doing any data access.

The code below defines and then uses a very simple scalar UDF that simply triples the input:

CREATE FUNCTION dbo.Triple(@Input int)
RETURNS int
AS
BEGIN;
DECLARE @Result int;
SET @Result = @Input * 3;
RETURN @Result;
END;
go
SELECT DataVal, dbo.Triple(DataVal) AS Triple
FROM dbo.LargeTable;

This example is obviously overly simple – even the most enthusiastic devotee of isolating and reusing code will never bother to define and use a function for something so simple. But if the calculation in the function is actually very complex, it’s easy to see how code that defines the calculation once and then simply invokes the function every time it’s needed is easier to build, understand, debug, and maintain than code that repeats the complex expression at several locations. In traditional programming languages, like C# or VB.Net, it’s easy to see why using functions to encapsulate and reuse common computations is considered a best practice.

But SQL Server isn’t a traditional programming language. It’s a declarative language, with an optimizer that has been designed to optimize the execution order within queries to make sure that the results are returned as fast as possible – without impacting correctness, of course. And that optimizer simply cannot optimize code that calls scalar UDFs as well as it can optimize code that has the same logic inlined. Let’s first take a look – in order to test the performance, I’ll create a table with 100,000 rows with random values from 1 to 10 in the DataVal column.

CREATE TABLE dbo.LargeTable
(KeyVal int NOT NULL PRIMARY KEY,
DataVal int NOT NULL CHECK (DataVal BETWEEN 1 AND 10)
);

WITH Digits
AS (SELECT d FROM (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) AS d(d))
INSERT INTO dbo.LargeTable (KeyVal, DataVal)
SELECT 10000 * tt.d + 1000 * st.d
     + 100 * h.d + 10 * t.d + s.d + 1,
       10 * RAND(CHECKSUM(NEWID())) + 1
FROM   Digits AS s, Digits AS t, Digits AS h,
       Digits AS st, Digits AS tt;

The code may be a bit complex and you may be tempted to write a simple loop to insert 100,000 rows. But that would take a lot more time – the code above runs in less than 1 second on my laptop, whereas a loop takes almost five seconds. When we need more rows (later), this difference becomes even more noticeable.

The first test

Now it’s time to test. Below are two queries. The first query is designed to calculate the triple of each DataVal value in the table. (Note that I added the MAX aggregate to ensure that the actual performance would not be impacted by the overhead of returning 100,000 rows to SSMS and rendering them in the result display). The second query is exactly the same, except that it doesn’t use the scalar UDF, but includes (“inlines”) the actual formula in the query.

SELECT MAX(dbo.Triple(DataVal)) AS MaxTriple
FROM dbo.LargeTable;

SELECT MAX(3 * DataVal) AS MaxTriple
FROM dbo.LargeTable;

If you select the two queries, activate the option to include the actual execution plan, hit execute, and then switch to the execution plan tab, you may be pretty happy:

I must add that I didn’t get these plans all the time. In my first tests, the plans were equal, with the only difference being the actual content (visible only in the Defined Values property) of the Compute Scalar iterator – the arithmetic formula 3 * DataVal vs. invoking dbo.Triple; in those cases both plans were said to have a cost of 50%. In later tests, the plans changed to the above; the call to dbo.Triple is now hidden several levels deep in the Defined Values property of the Stream Aggregate iterator, and though the same work is still done, the first query is now said to be suddenly slightly cheaper than the second. But either way, whether 50% each or 49% vs 51%, the scalar UDF seems to be a very good choice.

However, you may not be aware that the “Actual Execution Plan” is a dirty rotten liar. Or maybe I should say that the terms “Actual Execution Plan” and “Estimated Execution Plan” are misleading. There is only one execution plan, it gets created when the queries are compiled, and then the queries are executed. The only difference between the “Actual” and the “Estimated” execution plan is that the estimated plan only tells you the estimates for how many rows flow between iterators and how often iterators are executed, and the actual plan adds the actual data for that. But no “actual operator cost” or “actual subtree cost” is added to the corresponding estimated values – and since those costs are the values that the percentages are based on, the percentages displayed in an actual execution plan are still based only on the estimates.

To get a better idea of the actual query cost, let’s run these queries again – this time without the execution plan, but with the actual duration displayed. You can enable this display with the option Query / Query Options / Advances / SET STATISTICS TIME. Or you can simply add the statement SET STATISTICS TIME ON; at the start of the batch (and SET STATISTICS TIME OFF; at the end). Now, if you run the queries, you’ll get some extra information returned (in the Text tab of the results pane) that tells you exactly how long the query took (elapsed time) and how much CPU time it used (CPU time). On my laptop, the query that uses the UDF takes 889 ms CPU and 900 ms elapsed, and the query with the logic inlined takes only a fraction of that: 47 ms CPU and 52 ms elapsed! Not 49% versus 51%, but 95% versus 5%.

Why?

This huge performance difference is caused by the overhead of calling and executing a scalar UDF. The computation of 3 * DataVal in the second query is entirely executed inside an iterator (the Compute Scalar), which is very efficient. The computation of dbo.Triple(DataVal) in the first query is also executed in an iterator (the Stream Aggregate, in this case) – but since this is a call to a separate module, SQL Server will have to invoke this module for each of the 100,000 rows flowing through that iterator. Each of those 100,000 calls introduces some overhead: start up the execution, step through the two executable statements of the function body, and clean up afterwards. Some sources claim that the function text is interpreted (compiled) on each call; I found that this is –at least on SQL Server 2012– not the case; when executing this code with a profiler trace running, only a single cache hit (or cache insert if the function is not in the procedure cache) event is fired.

This overhead is invisible in the “Actual Execution Plan”, but the execution time and the profiler trace tell a different story. And so does the “Estimated Execution Plan” – if I select the query that uses the function and then request at “Estimated Execution Plan”, I get two execution plans: one for the query that we saw before, and one for the function body, with two iterators that represent the executable statements: a SET with a calculation, and a RETURN.

But note that, again, the execution plan is lying. First, it implies that the UDF is invoked only once, which is not the case. Second, look at the cost. You may think that the 0% is the effect of rounding down, since a single execution of the function costs so little in relation to the cost of accessing and aggregating 100,000 rows. But if you check the properties of the iterators of the plan for the function, you’ll see that all operator and subtree costs are actually estimated to be exactly 0. This lie is maybe the worst of all – because it’s not just the plan lying to us, it is SQL Server lying to itself. This cost estimate of 0 is actually used by the query optimizer, so all plans it produces are based on the assumption that executing the function is free. As a result, the optimizer will not even consider optimizations it might use if it knew how costly calling a scalar UDF actually is.

Determinism

You may have wondered why SQL Server even bothers to invoke the UDF 100,000 times. Based on the CHECK constraint, there can never be more than 10 distinct values in the DataVal column – so why doesn’t the optimizer transform the execution plan to first get the distinct values of DataVal, then call the UDF only for those? Surely, that would be more efficient? Yes, it would, as we can easily verify by making that transformation ourselves:

SET STATISTICS TIME ON;
SELECT MAX(dbo.Triple(DataVal)) AS MaxTriple
FROM (SELECT DISTINCT DataVal
FROM dbo.LargeTable) AS d;

SELECT MAX(3 * DataVal) AS MaxTriple
FROM (SELECT DISTINCT DataVal
FROM dbo.LargeTable) AS d;
SET STATISTICS TIME OFF;

If you check the returned execution times, you will see that this technique even helps the performance of the query without function, if only by a little bit – 47 ms CPU and 50 ms elapsed on my laptop. For the version with scalar UDF, the saving is significant, as it is now almost as efficient as the version without scalar UDF: 62 ms CPU and 51 ms elapsed.

So why does the optimizer not make this transformation by itself? There are two reasons for that. The first is that with this version of the UDF, it can’t guarantee that this transformation won’t change result, because of a property called “determinism”. If a function is deterministic, we can be sure that when it is invoked multiple times with the same arguments, it will always return the same result. If a function is not deterministic, it might return different results, even when the same parameters are passed in. Our scalar UDF is not deterministic, as this query shows:

SELECT OBJECTPROPERTY(OBJECT_ID('dbo.Triple'), 'IsDeterministic');

You can check Books Online for a list of all the requirements a function has to meet to be deterministic. In our case, the only problem is that the UDF is not schemabound, so let’s remedy that:

ALTER FUNCTION dbo.Triple(@Input int)
RETURNS int
WITH SCHEMABINDING
AS
BEGIN;
DECLARE @Result int;
SET @Result = @Input * 3;
RETURN @Result;
END;
go
SELECT OBJECTPROPERTY(OBJECT_ID('dbo.Triple'), 'IsDeterministic');

The function is now marked as deterministic – but if you rerun the previous tests, you’ll see that this does not affect plan choice for these queries at all! The optimizer still won’t shuffle the plan of the first query to match that of the second, even though they are now (with the function marked deterministic) guaranteed to be equivalent. That is because there is a second reason why the optimizer won’t make this change – and that is that the optimizer thinks that invoking the function has a zero cost. Why would it even consider a complicated plan transform that saves 99,990 function calls if it thinks that those calls are free? After all, zero multiplied by 99,990 is still zero. Unfortunately, whereas we can affect determinism of a function, we cannot influence the cost estimate the optimizer uses for it.

This same zero cost estimate leads to more bad plan choices. For instance, in the query below, the optimizer will happily invoke the scalar UDF two times for each row: once for the WHERE and once for the SELECT:

SELECT 1 - dbo.Triple(DataVal)
FROM dbo.LargeTable
WHERE dbo.Triple(DataVal) > 20;

It gets worse

Unfortunately, these two (overhead times the number of rows and bad cost estimate affecting plan choice) are not the only problems with scalar UDFs. There is a third problem: SQL Server will never use parallelism in a plan that uses scalar UDFs. This becomes only visible with larger tables, so let’s get rid of our 100,000 test rows and replace them with ten million fresh ones:

TRUNCATE TABLE dbo.LargeTable;

WITH Digits
AS (SELECT d FROM (VALUES (0),(1),(2),(3),(4),(5),(6),(7),(8),(9)) AS d(d))
INSERT INTO dbo.LargeTable (KeyVal, DataVal)
SELECT 1000000 * sm.d
     + 100000 * ht.d + 10000 * tt.d + 1000 * st.d
     + 100 * h.d + 10 * t.d + s.d + 1,
       10 * RAND(CHECKSUM(NEWID())) + 1
FROM   Digits AS s, Digits AS t, Digits AS h,
       Digits AS st, Digits AS tt, Digits AS ht,
       Digits AS sm;

If we now execute our original queries again, we will see two changes over the first time, when we used 100,000 rows. The first change is that now the plans are not the same; the plan for the query with scalar UDF is still the same, but the plan for the query without scalar UDF introduces parallelism.

The second change is maybe not really a change – it’s the observation that the percentages in the plan are still way off. On my laptop, the query with UDF takes 40108 ms CPU and 43760 ms elapsed to process all million rows; the query without UDF does the same in 4397 ms CPU and 808 ms elapsed. Based on CPU usage, the UDF version takes 90% of the batch (making the difference slightly less than in the non-parallel version – this is caused by the overhead of synchronizing over all the threads and combining the results); based on elapsed time, it’s even 98% (based on all cores in my laptop working instead of just one).

I made another interesting (and slightly disturbing) observation when I looked at the execution plans of the queries that force the optimizer to first find the distinct values of DataVal and then only invoke compute the triple of those distinct value:

The version without UDF uses the parallel part of the plan to read all rows and find the distinct DataVal values, then computes the triple for those distinct values in the serial part. I would have expected a similar plan for the version with UDF (since the UDF would only be called in the serial part), but apparently, the mere presence of a scalar UDF in the query prevents any form of parallelism for the entire execution plan!

The remedy

If you care about performance, you should avoid the use of scalar UDFs, except in situations where their performance hit doesn’t hurt. For instance, in a SET statement without subquery, a UDF does not hurt you, because it will be invoked only once. And in a SELECT statement that processes only a very small table and is not part of a time-critical part of your system, the performance hit doesn’t really matter much (but don’t think that it’s safe to use a scalar UDF in a query that returns only a few rows from a large table – sometimes the optimizer will produce a plan where the evaluation of the UDF is pushed down to a part of the plan that is executed before the majority of the rows is filtered out!)

The obvious workaround is to not use a scalar UDF at all, but instead inline the code. For the Triple function I used here, this is dead simple. If you have a UDF that contains multiple statements, calculating and storing intermediate results in variables, doing conditional logic based on IF … ELSE blocks,etc – this can be quite hard. You may have to use complicated CASE expressions, and you may have to repeat expressions multiple times (or use CTEs to avoid that duplication). But the performance gain will make up for the effort! Just don’t forget to carefully comment and document the sometimes hideous queries this may result in. As an example of what I mean, look at this scalar UDF and the corresponding inline rewrite (and if you want to know what the use of this UDF is, there is none; it’s just some nonsense I made up).

CREATE FUNCTION dbo.Nonsense(@Input int)
       RETURNS int
       WITH SCHEMABINDING
AS
BEGIN;
DECLARE @Result int,
          @BaseDate date,
          @YearsAdded date,
          @WeekDiff int;
SET @BaseDate = '20000101';
SET @YearsAdded = DATEADD(year, @Input, @BaseDate);
IF @Input % 2 = 0
BEGIN;
    SET @Result = DATEDIFF(day, @YearsAdded, @BaseDate)
                - DATEDIFF(month, @YearsAdded, @BaseDate);
END;
ELSE
BEGIN;
    SET @WeekDiff = DATEDIFF(week, @BaseDate, @YearsAdded);
    SET @Result = (100 + @WeekDiff) * (@WeekDiff - 100);
END;
RETURN @Result;
END;
go

SELECT KeyVal, DataVal,
dbo.Nonsense(DataVal)
FROM dbo.LargeTable
WHERE KeyVal <= 100;

WITH MyCTE
AS (SELECT KeyVal, DataVal,
           CAST('20000101' AS date) AS BaseDate,
           DATEADD(year, DataVal, CAST('20000101' AS date)) AS YearsAdded
    FROM   dbo.LargeTable)
SELECT KeyVal, DataVal,
       CASE WHEN DataVal % 2 = 0
            THEN DATEDIFF(day, YearsAdded, BaseDate)
               - DATEDIFF(month, YearsAdded, BaseDate)
            ELSE (100 + DATEDIFF(week, BaseDate, YearsAdded))
               * (DATEDIFF(week, BaseDate, YearsAdded) - 100)
       END
FROM   MyCTE
WHERE KeyVal <= 100;

The query with the logic inlined may not look pretty – but if I execute the query for all ten million rows in the table (again using the MAX aggregate to reduce I/O and rendering overhead), the performance difference makes it worth it: over a minute for the UDF version, versus less than 4 seconds for the inlined version!

What’s next?

In the next part of this series, I’ll look at how data access in a scalar UDF changes the situation – to the worse! After that, I’ll check the two types of table-valued functions. Where scalar UDFs are good, table-valued UDFs can be downright ugly – or they can be good, depending on the type. I will also present a way to replace scalar functions with inline table-valued functions, so that you can encapsulate and reuse code without paying the gigantic performance penalty of scalar UDFs – but at the cost of complicating your query. So stay tuned!

OT: Noisy v. Important

andyleonard — Wed, 25 Jan 2012 12:00:00 GMT

A new personal blog post: Discerning Between Noisy and Important

Stand-Up Cloud Computing

BuckWoody — Mon, 09 Jan 2012 13:33:28 GMT

When I was very young, I asked my uncle for career advice. He went silent, thinking for a bit, and then said: “People who work sitting down make more than people who work standing up.” I’m not certain how true that really is, but my career as a technology professional has led me to work in a seated position for most of my life.

Turns out, that’s a bad thing. Although I consider myself pretty fit, eating right, sleeping well and working out several times a week in addition to a morning walk with the family each day, I always look for low-barrier ways to stay healthy. When I first moved to the Pacific Northwest to work for Microsoft, I noticed several folks working at tall desks with no chairs. Some even had treadmills. I chalked it up to the ethos here; and certainly not something I would do.

But this year that changed. I noticed that my back was a little stiffer when I got done with my 12-13 hour days of work. For the last couple of years, I’ve worked from home, so I don’t attend meetings (at least in person) as often or have to walk very far to do almost any part of my job. I start work around 6 in the morning, and sometimes get so focused that I don’t moved for many hours. I read an article on how bad sitting really is, and after further investigation thought I might give one of those stand-up desks a try.

The research led me to believe that you don’t actually have to use a stand-up desk per-se, you can also use an alternate chair or just get up every so often. But I wanted to try this out, and figured that I would be more likely to take a break and sit every hour than I would to remember to stand every hour.

The Before

My office desk is fairly typical, but I do have a decent office chair. That’s after going through probably six or seven chairs in the last few years. I have good lighting, a speakerphone, a web cam and two monitors. I also have the typical flotsam and jetsam of desk clutter, although I’m neater than some.

This arrangement has suited me well since I’ve been working at home. I had something similar in an office environment, although I didn’t always have the option of a decent chair. I didn’t go through the trouble of bringing one of my own in; I just put up with whatever I got, or could “appropriate” from an empty office or conference room.

The Build

My criteria were fairly simple: the experiment had to cost less than 100.00, and be at the proper height and size to hold my keyboard, trackball, phone and monitors so that I could type with my elbows staying at a 90 degree angle.

After researching standing desks, 100.00 was going to be impossible, not even for a used one. I visited several thrift shops in the area (I do that a lot anyway to donate and to buy) and didn’t find anything that worked. Of course, when you’re faced with finding cheap furniture, you naturally turn to the most amazing store on the planet.

Before I left, I measured the top area and height of my desk, and wrote down acceptable measurements based on how I high I stood, the stuff I needed the top to hold, and the distance I needed for my typing to be done at the right height. Measurements in hand, I headed to the store.

I found a coffee table - a really cheap one (19.00) called (oddly) LACK and brought it home to begin the surreal process of assembling something bought at Ikea.

Happily, this was REALLY simple. Four lag bolts hold the legs on, and eight screws punched into the wood (or at least wood-like) to attach the shelf. My original thought was that I would move the shelf up higher than the Ikea instructions, and then use the pull-out tray from my desk to put the keyboard and trackball on. However, that was not to be. On investigation I found that the tray was not hung underneath the desk, but attached at the sides. That meant I had to either buy another tray, or place the keyboard on top, necessitating standing two inches higher.

The After

Researching trays, I found they were terribly expensive. These things used to be everywhere, so I was surprised that they aren’t as easy to get as they once were. Off to the thrift store to see what they had. I found an older tray, but it looked flimsy. I then found a child’s plastic picnic table. The plastic was strong, and 1.5 inches thick. I figured I needed some padding to stand on anyway, so I bought the table, pulled off the legs, and wrapped some padding in an older rug. This brought the total cost of the build to 25.00 and 2.00 for an espresso and a cinnamon bun at Ikea (I would be burning these calories off with my new desk, after all).

I re-routed all my cables, and everything fit correctly.

My Early Conclusions

The first day was easy. I thought - well I should have done this a LONG time ago! My back wasn’t that sore, and I didn’t feel that tired.

Then I woke up the next morning. My feet were sore, although not terribly. The second day, I had to sit down each hour. Not just wanted to sit down - needed to. I play in a group at Church on Sunday, so I put my guitar in the office and spent 5 minutes each hour (roughly - sometimes I have calls that are longer than that) and practice a little sitting down. That helped a lot.

I’ve now been at the desk for four days, and I don’t need the breaks as often. I also find I need to shift around a lot, which of course burns even more calories and is better for me. I honestly think the treadmill desk might be easier than a standing one. We’ll see if I go that far someday.

The verdict so far? Glad I’ve done this. If it doesn’t work out, I’ll just re-purpose the coffee table and go back to sitting - although I’m pretty stubborn and will probably stick with this for a while. I’ll let you know if I change back, and why.

My executive assistant hasn’t changed her office arrangement at all. She still keeps her (Ikea) chair just like she’s had it since she started working with me, and dutifully stays at her workstation for the entire 12-13 hours each day. We do, however, take our lunchtime walk still. She burns her calories that way, and thinks it’s better than just standing around all the time.

What Matters Most

andyleonard — Sun, 25 Dec 2011 12:00:00 GMT

The end of the year is a study in extremes. For many, it is a time of merriment and celebration. For some, it is yet another day to survive.

I believe most people reflect on the past year as it draws to a close. We think about the things that happened over the year: the accomplishments of ourselves and others; goals set and met; goals not met; gain; losses; and the inevitable change that happens to us all every year. It’s likely this year has been a mixed bag for you as it has been for me. There have been high highs and low lows.

Examples? Wow, there are many. Some subtle, some not. In roughly chronological order:

Watching SQLPeople grow
Starting Andy Leonard Training, Inc.
Writing SSIS Design Patterns and the SSIS Stairway series at SQLServerCentral.com
Speaking at Connections, several SQL Saturdays, the PASS Summit, and SQLBits

Do these things matter? Sure. But do they matter most? Not by a long shot. Here are some examples of things that happened in 2011 that matter most:

Celebrating another year married to Christy
The birth of my latest grandchild, Gabriel
Stevie Ray’s appendectomy
Riley starting school
Meeting with fellow believers at the PASS Summit for PASS Prayers
Meeting regularly with a small group of committed Christians to study the Bible
Participating in SQL Server MVP Deep Dives, Volume 2
Starting Linchpin People with my friend and brother, Brian Moran

Can you spot the difference? What matters most involves people. Most of these events were incredibly positive – awesome, in fact. Some were and are great but are continuing to mature. I still cannot bring myself to think for long about Stevie’s appendectomy; the harsh realities of that situation still chill my soul.

High highs and low lows.

As the year has progressed, I have become more and more aware of how truly blessed I am. I deserve none of it, and yet much is given to me. A bunch of it comes my way as a winner of the Birth-Nation Lottery. We have so much in America. As I read recently on a friend’s blog, many of America’s poor post on Facebook or Twitter about their needs and concerns from their iPhones. Destitution exists in America, but this isn’t it. This isn’t the poverty others experienced as children. The fact that most of America’s poor are among the richest in the world is a thing of mixed emotions. I hurt to see anyone in poverty – in America or elsewhere – and this pain is motivating.

Motivating For What?

I believe I can do better and more to help. The faith I share with millions compels me to do more. So I am doing and will do more. My watchword for 2012 is “intentional”. Plans are already underway to intentionally work to reduce the poverty of those in the United States, Europe, and elsewhere. I don’t know how many of these actions will make it to the annals of this blog. I am certain some of these activities will appear here, though they will likely not be advertised in the category of “reducing poverty”. I will have no such category on this blog. Or any blog.

I have endeavored my entire career to give back. This will continue, though with a bit more focus, planning, and (yes) intent.

I am truly blessed to have a business partner who shares faith, philosophy, and a desire to implement positive change in the workplace. Brian has taught me much technically, but he has taught me much more about endurance and faith. I am honored to work with him. We are endeavoring to create a different kind of business; one that enables what Tom Nelson calls “human flourishing” in Work Matters. That sounds lofty, mostly because it is. The Linchpin People website went live earlier this month even though we’ve been in business since April. We are architecting Linchpin People to be different, and different takes time. We are building a culture by defining a philosophy. Beyond that, we are cognizant of the movements around us. We are leveraging them at a minimum; we may be starting a movement – time will tell. I would love to share an optimistic story with you, but the starkness of our beliefs compel us to face the reality: this may succeed or this may fail. Only time will tell.

That’s not all. But that’s all I want to share here and now.

Be Intentional

I want to encourage anyone so inclined to be intentional in 2012. I lack the words to adequately express how it feels to know something you did made a difference in someone’s life. Suffice it to say it is unlike any other positive feeling I have experienced.

Help someone less fortunate. Be there for people who need you. This isn’t always as straightforward as it sounds, as sometimes tough love is what they need most.

We are a community of brilliant problem-solvers. Can you imagine what we can accomplish if we simply put our minds and hearts and hands to it? Just think of the things we can do; things for people; things that matter most.

Andy

Book Review (Book 2) - Rhetoric by Aristotle

BuckWoody — Thu, 28 Jul 2011 14:27:16 GMT

This is a continuation of the books I challenged myself to read to help my career - one a month, for year. You can read my first book review here. The book I chose for July 2011 was Rhetoric, by Aristotle. You can read it here for free: http://ebooks.adelaide.edu.au/a/aristotle/a8rh/

Why I chose this Book:

I read this long ago, but I would like to re-read it to learn how to more clearly formulate my arguments and help my writing skills to improve. This book is the foundation for arguing a point - which we all do, or at least need to do, every day. Arguing does not imply an adversarial relationship; it merely means you’re trying to persuade someone to see your point of view.

What I learned:

Even though this work is thousands of years old - boggles the mind to think of what has occurred in that time - people are largely still the same. During this work Aristotle talks about everything from psychological motivations for good and bad to politics and power. And it seems his observations are still dead-on. What that taught me is that people deep down have very common descriptors, even across cultures. Knowing those motivators gives you an “edge” in a discussion. If you know someone’s position in war, a game, or in a negotiation, you have a powerful tool to help them understand your position, potentially getting what you want.

This all sounds rather manipulative, but it isn’t. Aristotle starts out by stating that your own motives and positions need to be evaluated before you even attempt the argument to ensure you’re on solid footing. And he states that your argument should be to change behavior for the better, not for evil. He even defines what those things mean.

It’s all done in a very syllogistic (logical argument, A+B=C kind of thing) fashion, which is very direct if not a little too black and white. And of course he is a bit chauvinistic in places and some of the examples are not easily translated - but if you can overlook those things you can learn to be a better communicator, whether that is at a 1-1 level or speaking to large crowds. A very recommended read.

Raw Notes:

I take notes as I read, calling that process “reading with a pencil”. I find that when I do that I pay attention better, and record some things that I need to know later. I’ll take these notes, categorize them into a OneNote notebook that I synchronize in my Live.com account, and that way I can search them from anywhere. I can even read them on the web, since the Live.com has a OneNote program built in. Note that these are the raw notes, so they might not make a lot of sense out of context - I include them here so you can watch my though process.

(There are actually three books in this one work, but I’ve only posted the notes from Book 1 here)
1. An interesting read overall – but I think it deals mostly with the speaker, and not enough with the medium and methods to influence the receiver. It does, however, explain the motivations of the listeners, so you can form your own way of dealing with this.
2. I often read about the book before I read the book – (How to Read a Book - definitely check this one out)
3. Considered a series of notes by his students more than a purpose-written book
4. Reading it because it is considered the foundation of persuasion, one of the many goals of communication
5. In fact, persuasion is touted as the only goal of debate.
6. Learned more about enthymemes, which are aimed more at persuasion than demonstration.
7. Beginning was a definition of terms – very nice. (Book 1)
8. In defining an argument, “non-essentials” should not be allowed. This avoids many logical fallacies.
9. Wow – he prescribes that the law should be carefully defined, and not left to judges to interpret. Objectivity is the goal, and is not entirely possible with human beings.
10. The discussion of judges at the fore seems to indicate that the argument’s decider is the most important decision. Good take-away.
11. Reading with a good dictionary is essential. Do not skip over any part of a word you do not understand.
12. He teaches that speakers are the representative of truth – if truth does not prevail, it is the fault of the speaker.
13. Not everyone learns in the same way, so studying rhetoric is a way of obtaining multiple ways of teaching.
14. You must understand both sides of an argument in order to fully argue your position.
15. Great good, and harm, can come of skill in speaking than in skill at arms.
16. Medicine is not just to make you healthy again, it can also be used to make you as well as possible.
17. Three influencers of persuasion: personality, audience preparation, and proofs.
18. There are many divisions of topics into numeric orders – I do this a great deal as well. Not sure of the meaning of that, if any.
19. Reading classical works is interesting – the breakdown of sentences is like a syllogism itself.
20. Amazing – in chapter four, he details the effects of political speech, and even details some of our current systems by name, such as “Ways and Means” and “National Defense”.
21. Chapter four deals with political knowledge required to argue effectively, but this can be extended to all facets of life. Basically he says “know yourself, know your enemy, know your environment.” Sage advice indeed, and far too often ignored by the dim lights we continuously put into office.
22. Chapter five says that happiness is “prosperity with virtue” – and further defines it as “independence”. Amazing how much of that we are willing to give away.
23. Definitely some elitism espoused.
24. Chapter 6 deals with what is "good", or "right". This is a foundation for arguing a position, since your argument is easily lost if it is not deemed within the realm of "rightness". Aristotle seems to base what is good on what is found in nature, although it is interesting that fairness, which most consider good, is not a natural construct.
25. In Chapter 7 Aristotle makes good use of building logical arguments, classically using syllogisms to do so, as you might expect
26. In Chapter 8, Aristotle continues the theme that the more knowledge you have, the better your arguments will be. In fact, it seems to follow that perhaps you will settle your own internal arguments as you learn more, and perhaps not need to argue a particular point at all.
27. He states that the impetus of most arguments is no impetus at all - that is, most of the time the primary goal is the continuation of the established order.
28. He explains the various forms of government to complete Chapter 8.
29. Chapter 9 begins with a discussion on how to be empathetic in your arguments, that is, to make the other person agree with your point, so that it is as much their idea as yours.
30. To accomplish this goal, Aristotle feels that your argument should be noble and virtuous, and explains what both of these means. In essence, he states their meaning is the most good for the most people.
31. He also states the passive form of the Golden rule, as well as the Active form.
32. Wow – he gets a bit chauvinistic in this chapter, stating that a man’s actions will be more noble than a woman’s!
33. Part of getting the agreement of point of view is to basically flatter or call out the good in another person.
34. Chapter Ten covers figuring out more about those that do “wrong”, and in true philosophic fashion, he defines the term wrong first.
35. He states that we do “wrong” based on the nature of our character. That is, whatever your character weakness is, the wrongdoing will be exposed along that fault line. So it follows that knowing someone’s character can aid you in arguing with them.
36. Character, then, leads to predictive analysis. He has not discussed the danger of this type of activity.
37. It is quite interesting to evaluate my own actions based on some of the “motivators” Aristotle puts forth in this chapter. Knowing yourself – however uncomfortable a process that might be – is also key to winning your argument.
38. Chapter 11 covers a range of human emotions and a very Epicurean view, but I do like this quote: “Where there is competition, there is victory.” Sums up the human condition quite nicely. We have to compete, it is our nature. Shying away from it will not help.
39. Chapter 12 deals with the ways that people try to avoid punishment for their actions, especially the wealthy and politically connected. Not much has changed, it seems. ?
40. He also explores the darker side of rhetoric, and how some use it to avert judgment.
41. In chapter 13 he explains the differences between specific law, written down, and “universal law”, which he deems to be inherent. This is not a reasonable position, in my mind. Each person interprets that differently.
42. Chapter 14 deals with the results based on acting on these laws, both justly and unjustly.
43. Chapter 15 explains other means of persuasion, including contacts, promises and even torture. An interesting take on convincing folks to see things your way, and once again, quite timely! Seems in 2000 years of human history, we have not learned a great deal.

Head in the Clouds–Eyes on the Books

BuckWoody — Tue, 07 Jun 2011 19:43:00 GMT

I normally post technical topics here on this blog, but I’m extending this post a bit to include a little professional development. Don’t worry; there’s some tech (and Distributed Computing tech, no less) in this post as well.

I recently presented a few sessions on a “SQL Cruise” to Alaska (more on that here) and one of those sessions was on professional development. As part of that, I had everyone do some exercises on career building, and we created some deliverables we would be accountable to each other on. After all, one of my favorite business quotes (my version, others have said something similar) is:

What gets measured gets done.

One of the deliverables was to establish our career goal(s) for the next year, and then come up with a list of 12 books that would help us get there. We promised to read one book per month, and report back on our blogs a review of the book and how it applies to the career. So in no particular order, here is my list – I’m telling you all, so call me on it if I don’t post a review on one of them. I reserve the right to change my list as I learn more, but 12 books is the rule:

Programming Windows Azure by Siriram Krishnan: Learning about how to select applications suitable for Distributed Technology. (June )
Rhetoric, by Aristotle: I read this long ago, but I would like to re-read it to learn how to more clearly formulate my arguments and help my writing skills to improve. (July)
Favorite Folktales from Around the World, by Jane Yolen: Storytelling is at the heart of presenting well. ( August )
Predictably Irrational, Revised and Expanded Edition: The Hidden Forces That Shape Our Decisions, by Dan Ariely: Understanding the actions of others is key to my success. ( September )
The Cloud of Unknowing, Anonymous: The role of faith in life. ( October )
Wikinomics: How Mass Collaboration Changes Everything, by Don Tapscott: I’ve heard a lot about this, and I’m not even sure I agree with it. But I want to see what it says about collaborative efforts and how I can leverage them. ( November )
Think Stats: In my studies of "Big Data", the skill I find missing most of the time is Statistics - as part of the "Data Scientist" role I'm investigating, this is part of a kit you can get from O'Reilly. I actually replaced another book with this one. ( December )
The Elements of Persuasion by Richard Maxwell and Robert Dickman: Another "storytelling" book. ( January )
Designing Data Visualizations by Noah Iliinsky and Julie Steele: Part of my "Big Data" focus. ( February )
The Information: A History, a Theory, a Flood by James Gleick: This is a book I've heard a lot about, and it's in a similar vein as GEB, one of my favorite books. ( March )
Applied Architecture Patterns on the Microsoft Platform: Using Microsoft products to solve a given problem. It includes Cloud strategies as well. ( April )
20 Master Plots by Ronald B. Tobias: Stories and themes are part of software, presenting, and working in teams. This book claims there are only 20 plots, ever. Let's see. ( May )

As part of keeping each other accountable, I hereby tag a few of my fellow travellers – and you, of course, are invited to play along. Link back to this blog post and put your link in the comments below if you want us to follow your journey:

Tim Ford: http://thesqlagentman.com/
John Halunen:
Dev Nambi: www.devnambi.com
Grant Fritchey: http://www.scarydba.com/

Computer books are dead. Well, some of them, anyway.

BuckWoody — Tue, 10 May 2011 13:58:23 GMT

I read a lot. I mean a LOT. It seems that computer professionals have much in common with medical professionals – we have to read in order to stay on top of our game. For me, this used to mean web sites, magazines, and other print medium, and of course lots of books. I’ve even written several computer books myself and had them published.

Whenever I teach a class, do a presentation, or hold an architectural design session on a new (or new to that person) technology, they usually follow up with “what’s a good book for learning X technology?” This happens so often that I have a list I keep of the titles I like for a particular subject – you probably have similar book lists.

Windows, SQL Server, and other Microsoft products change on an average of around three or four year cycles. That’s enough time to play with a beta product, wait until it releases, and write a solid book about it, and have that in a decent market for sales, and allow people to read and recommend it.

Enter “the Cloud” – Distributed Computing.

Windows Azure and SQL Azure don’t release every three years. Changes – some of them dramatic – release every three or four months. You can’t even write a book that fast, much less update it that quickly and re-sell it. So what is a technical professional to do?

Well, although I really like a couple of books I’ve read so far (especially this one, print and e-book version here), they are out of date almost by the time they publish. Instead, I rely on blogs, the web, documentation from the vendor and how-to articles published online. Many of these, ironically, are stored, hosted or delivered using – wait for it – Windows Azure. That’s interesting because it’s a medium that describes itself – “reflection”, anyone?

This brings up an interesting conundrum. Books have a version, are arranged, thought-out and categorized. Since I’m now getting information off of the web, it’s difficult to figure out whether that material is correct at the time, what level it’s aimed at – and forget about any coherent structure. It’s topic-by-topic.

So, like most of you, I use links and favorites to arrange things. And I found myself making “virtual books” by essentially creating my own Table-Of-Contents. I’ve shared some of those, such as my Windows and SQL Azure Learning Plan. The key is that I have to update that to ensure that the latest information is there – otherwise it becomes an organized list that is not authoritative.

Don’t get me wrong – I still have tons of (e-book format) books, especially on “conceptual” topics like development paradigms and so on. But when it comes to specifics and how-to’s – electronic medium is best for me. It’s more current, adaptable, searchable, interactive and immersive than books. But how long will I retain regular print-type books? We’ll see. Times, they are a changing – fast.

2010 Goals Review

andyleonard — Fri, 31 Dec 2010 12:00:00 GMT

Introduction

Earlier this year, I responded to Tim Ford's (Blog / Twitter) tag (in a post about 2010 Resolutions and Themeword) with 2010 Themeword and Goals. Let's see how I did.

Resolutions

1. I need to take better care of Andy.

On this, I failed. I took even worse care of myself than before. I have to address this in 2011. You can help by pinging me on Twitter (@AndyLeonard) every day in 2011 and ask me if I've exercised today.

2. I want to continue to serve the SQL Server community in several ways; including writing and serving as an advisor for user groups and community organizations.

On this, I believe I met my goal. I may have exceeded it with SQLPeople. Time will tell.

3. There will be CTPs for SQL Server vNext in 2010 - I want to learn everything I can about the new and improved features.

On this, I could have done better. My day job kept me pretty busy this year and this cut into my "play time". That will change in the new year. More on this in an upcoming blog post.

ThemeWord

My themeword for 2010 was Mentor. I believe I achieved this in several professional arenas. Even though I stepped aside as a PASS Regional Mentor, I continue to serve as a mentor for the technical community. I even helped restart the Roanoke Valley SQL Server Users Group after I stepped aside.

For 2011...

I'm going to stick with the spirit of those 2010 resolutions.

Take care of Andy.
Serve the community.

An Abbreviated History of Andy, Part 1

andyleonard — Fri, 22 Jan 2010 12:00:00 GMT

Introduction

After Paul Randal (Blog – @PaulRandal) tagged him in a post about the three events that brought him here, Brent Ozar (Blog - @BrentO) tagged me in his cleverly titled You may ask yourself, How did I get here?

So. How did I get here?

1. Christy

I recently read an article about how some relationships help the people in them realize their potential. There is support for each other's goals and dreams, encouragement and freedom to pursue them. There is evidence that this support enables partners in such a relationship to achieve more than they would have without the relationship. (If someone can find this, please comment!)

When I read that I tweeted "This happened to me!" Christy supports me like that. Christy rescued me. She has faithfully supported and encouraged me, and I'm so in love with her I can't breathe without her. She's my other self.

Christy is my best friend. If I have a question about a thought or plan, I can (and do) talk to her about and get sound advice. She's a fantastic wife, mother, cook, blogger, and everything else.

2. My friend John.

When I was 10, my folks bought 3 acres of land between Blackstone and Amelia Virginia on which they placed a three-bedroom mobile home. Our neighbors were aging and one of their sons, John, retired from the US Air Force and moved back home to take care of his parents.

John was an electronics technician in the Air Force. When he came home, John bought and built a Southwest Technical Products M6800 computer kit. Although I cannot find an image of it, John first built a Motorola 6800-based trainer. For those unfamiliar with the term, a trainer is a microprocessor with bare-bones I/O. In this case, toggle switches for input and LEDs for output.

John saw I had an interest in what he was doing. He was a natural mentor and asked my parents if he could teach me about computers. They agreed and in May 1975 I began learning Motorola machine code. That Fall I learned BASIC.

John changed my life.

3. Brian Knight (Blog - @BrianKnight)

Shortly before Christy and I were married, I moved to Jacksonville Florida. After we married she joined me and we lived there for three and a half years. Stevie Ray and Emma Grace were born in Jax, and we still have good friends in the area.

While in Jacksonville I held three positions. The last was DBA manager at Allstate, where I worked for Brian Knight. I met Brian via email when I signed up for the Jacksonville SQL Server Users Group. Brian advertised a job opening at Allstate through his mailing list and I applied. I did not get the job but I did a decent interview, and Brian hired me when another position opened a month later.

I read somewhere most authors receive 70 rejections before their first acceptance. When Brian was working on the Professional SQL Server 2005 Integration Services book, he needed more authors and asked me to contribute. I was honored! Participating in that book project was a lot of work, but it changed my career.

Conclusion

I'd say those are the three most influential reasons that brought me to this place in my life. And Brent, my military experience would be fourth on this list.

I tag Joe Webb, Jessica Moss, and Jorge Segarra.

:{>