Category Archives: Architecture

A Good Book Has No Ending

Posted on June 8, 2011 | 1 Comment

“A good book has no ending” – R.D. Cumming

Last week I was immensely lucky to be at SQL Cruise Alaska, and to attend Buck Woody’s (b / t) session on career development. A mere two hours later, I came away with about 5 pages of notes, a stunned expression, and the realization that I have not been sufficiently proactive in my own career. I’ll have a more complete write up in a few days, but one of the things Buck did was lay down a challenge for everyone there.

The challenge is for each of us to read 12 books that will help us advance our careers, and then do book reviews on our respective blogs. Here are my book choices, in no particular order:

  1. Hadoop, the Definitive Guide, by Tom White. For a developer who does business intelligence work, Hadoop/MapReduce is now a requisite skill. This is double true with companies that have large amounts of data (web logs, etc). I’ll be using what I learn to analyze the stock market data I have been downloading from online APIs.
  2. Basic Business Statistics, by Berenson, Levine, Krehbiel, Stephan. Working with large data sets is important. Equally important is the ability to know what kinds of analysis are best for a given problem. That means statistical analysis. My knowledge in this area is insufficient, hence this book choice.
  3. The Long Tail, by Chris Anderson. The reason to read this book is because of a question: how does the Internet affect businesses? Therefore, how does the Internet affect business needs? Therefore, how does the Internet change who is needed in future businesses?
  4. Pro SQL Azure, by Scott Klein and Herve Roggero. I expect most medium-sized businesses, and all start-ups, to eventually use cloud computing for their IT needs. The cost benefits are too great to ignore. For me, that means learning a lot more about the best practices when doing database work ‘in the cloud’.
  5. On  Writing Well, by William Zinsser. As someone without a lot of writing experience, gaining writing skill is critical. My style as a blogger is not that accessible, and I believe my readers would benefit if I expressed ideas in a more intuitive fashion.
  6. 97 Things Every Programmer Should Know, by Kevlin Henney. As a working developer, I occasionally get ‘stuck’ in a problem and forget about tips and tricks that can help. Memorizing said tricks would make me more effective when I write code.
  7. Applied Architecture Patterns on the Microsoft Platform, by Seroter, Fairweather, Thomas, Sexton, and Ramani. This book was recommended to me by Brent Ozar (b / t), and I had the luxury of skimming through it one day at a library. In 10 minutes I had a half-dozen options to solve design problems I had been struggling with. I would recommend this book to senior developers and budding architects.
  8. Adapt: Why Success Always Starts With Failure, by Tim Harford. I read Tim Harford’s The Undercover Economist two months ago, and am highly impressed by how well he can convey complex ideas using intuitive examples. Rapid prototyping and innovation is the best way for any company to produce new products and services. That means building lots of projects, many of which will fail, in order to find a few runaway successes.
  9. The Mythical Man-Month, by Frederick Brooks. This is one of the classic books in software engineering because it spells out a lot of common wisdom, and then explains why it’s all wrong. I’m very curious about which aphorisms and assumptions I am using that are incorrect.
  10. The Data Warehouse Lifecycle Toolkit, by Kimball, Reeves, Ross, and Thornthwaite. I read this book four years ago, when I was starting as a junior developer. I didn’t understand a lot of it, but the basics I picked up were enough for me to rapidly understand what my mentors were trying to teach me. I hope to pick up a lot more nuance this time around.
  11. Design Is How It Works, by Jay Greene. A lot of the truly iconic products and services out there are successful because of amazing design. As a developer who does a lot of back-end work, user-facing design is not one of my strengths. This would help remedy that.
  12. The Innovator’s Way, by Peter Denning and Robert Dunham. I don’t believe a developer can be successful unless they are creative and innovative. Working in a large company makes that tricky sometimes. Having some best practices and the proper mental attitude would be very, very helpful.

The second part of the book challenge is to check on at least one other person at SQL Cruise to make sure they’re reading as well. I’m tagging a few other people. Enjoy!

→ 1 Comment

Posted in Architecture, Professional Development

Tagged , , , , , ,

DB Perf Is Like Cake: the Architecture Layer

Posted on April 22, 2011 | Leave a comment

“Re-think it, and perf will come”

Layer 4 of The Layer Model is the architecture layer.

The architecture layer represents the high-level system design of your application, the technologies used, and how various systems interact with each other. If you change your architecture to be a better fit for your application, you will get far better performance.

If you’re considering architecture work, that means you have tried all of the other, easier approaches to performance tuning. That means you have tuned your system’s hardware bottlenecks, tuned the indexes and queries being run, you have even tuned your table designs and data-access layer. What is left is an architectural solution.

How to Start

When people hear ‘architecture’, they often feel intimidated. Working with the entire system is daunting. Luckily, there’s a process that makes this easy. The key to architecture work is about choosing the right tools and design for the situation. Here’s a 4-step guide:

  1. What is the essence of the problem?
  2. What high-level designs do other people use for the same problem?
  3. Which design, after minor adjustments, is the best fit for your situation?
  4. What tools should you use for your modified system architecture?

Not that kind of essence

the essence of the problem

Architectural challenges have a root problem. This is the essential issue, that, if fixed, makes all of the other problems much smaller. Since we are IT professionals, identifying root cause is something we’re good at.

What is the root problem with your system? Do you have single 80TB database powering your entire reporting system? A single OLTP system growing by 10X every month? Are there 80 critical system components that each need to talk to all of the others?

Knowing the problem is half the battle.

What other architectures do people use?

Will work for hay and rainbows

Brilliant innovators are very rare

Some of us can produce brilliant, never-before-seen system architectures that work. They’re rare. For the rest of us, we mimic the designs and best practices we hear about. Doing this is very wise; you can learn the strengths and weaknesses of many system designs without trying them out.

Luckily for us, the SQL Server community is very active. Chances are you have access to a nearby SQL Saturday, lots of helpful professionals on Twitter, and a gaggle of blogs with great resources. Most importantly, all of the people I’ve met in the community are easy to talk to.

I can learn more about architecture in an evening than in 6 months of reading. How? I offer to buy a 6 smart, experienced engineers a round of drinks after an event, and ask them lots of questions. Or I will find the one subject matter expert in this area, and expense a fancy dinner. Your manager should happily pay a $200 bill to avoid 6 months of project headaches.

Find out what others have done, and you benefit from decades of experience at a very low price.

CHOOSING THE RIGHT DESIGN

Balancing requirements good judgment

The scales of IT are not blind

Now you know the core problem to solve, and what others have done that works.

You should pick a system architecture based on what you know. I do this in a 5-step process:

  1. What are the 2-3 most critical requirements for my system, and my business? Scale? Latency? Interoperability? Ease of adding new features?
  2. Which architectures do not do well with these requirements? Discard the ones that don’t fit.
  3. Of the remaining ideas, list the strengths and weaknesses of each.
  4. Pick one.
  5. Tweak the system design a bit, but only to address your critical requirements.

Choose the right design, using good judgment and a critical eye.

Using the right tools

stack of chairs

Some stacks are more fragile than others

You now have a proposed system architecture. Now you need tools. The last step is to pick a technology stack for the job. I’ve saved this step for last because the choice of system architecture should dictate which technologies you use, and not the other way around. I like to do the following:

  1. List the top 3 most common technologies for the problem. Is it SQL Server? WCF? Memcached? Windows Azure AppFabric?
  2. List the strengths and weaknesses of each. If you are familiar with a technology stack, that is a key strength.
  3. Pick one.

Pick the right tools for your design, and you’ll have an architecture that can last for years.

The Good: The GoodRe-architecting a system can give you a faster, more scalable, and easier to use system for years. It can reduce dozens of headaches for users and IT in one fell swoop. It can also foster a sense of camaraderie between IT, developers, program managers, and the business. After all,  you’re all in this together.

The Bad: The BadThis is high-risk work. Doing this without testing is a recipe for horror. Bad communications and planning dooms a project this size. A lot depends on the judgment and teamwork of a few key IT and development personnel.

The Ugly: Done wrong, you can completely screw up your system architecture, alienate various teams from each other, and lose massive amounts of money as your customers flee.

 

 

But wait, there’s more!

Several people have asked me for examples of architecture re-work, design tuning, and so forth. I’ll be putting together several posts over the next few weeks with examples, best practices, and anti patterns.

→ Leave a comment

Posted in Architecture, Performance Tuning, SQL Development

DB Perf is Like Cake: The Design Layer

Posted on April 4, 2011 | 2 Comments

“Refactor it, and perf will come”

Layer 3 of The Layer Model is the design layer. The design layer is the schema of your tables and the application interfaces into your database. Each table’s datatypes, the views and stored procedures used by applications, LINQ, Entity Framework…they are the design layer of your database. Clean up your design, and you will get better performance.

Work with your developers

Nothing you do will be this awkward

To do any of this work, there must be a good working relationship between the DBA team and the development team(s). Everybody needs to get along. These tuning techniques require DBAs, database developers, and C# developers to work well together. All of us will be working outside of our comfort zone.

Data-Access Tuning

The way that applications access your database has a lot of influence on how well your application behaves, and the load on your database. Does your UI or middle-tier use LINQ everywhere? Is it all done through stored procedures? Some other way?

Luckily, developers are pretty conservative (read: lazy), so your application probably only uses one set of tools to access the databases.

Stored Procedures

Lazy

Your sprocs should be this lazy

If your application always calls stored procedures (‘sprocs’), then you’re in luck. There are a lot of things you can do for performance tuning on your own. I’d recommend the following approach:

1. Do query tuning for the stored procedures in your system.
2. Do you have multiple applications hitting the same database? Consider making different stored procedures for each one. That way you can tune each application independently, and not have to worry about the others. That way a set of stored procedures becomes the application<->database interface layer.
3. Make sure each stored procedure is doing the minimum amount of work necessary. If you only need to return 2 columns to your application, only return those 2, instead of all 20 in the table.

Object to Relational Mappers

LINQ image

Think before you LINQ

If your application uses an Object-to-Relational Mapper (ORM) like LINQ, Entity Framework, or nHibernate, then brace yourself. ORM tools hide a lot of query information from DBAs. They don’t expose information on what queries they create, and those queries are often hard to tune because nobody can re-write them directly. They make it hard for anyone to understand what the application is doing with your database.

For this post, I’m going to stick with tuning LINQ to SQL, since it seems to be the most common ORM tool with my readers. Nowadays I can’t swing a stick without hitting someone who’s run into performance issues using LINQ to SQL. Some intrepid souls have even benchmarked the performance hit you might receive, and the results may make you want to cry.

Sad face

Tools that make queries 8x slower make me cry

Luckily, this problem is common enough that there are a lot of resources around how to go performance tuning. Some of my favorites are below.

All of these resources require that DBAs and developers work together. They often require that developers have access to a database that’s similar in size to your production system, to find out what’s going on. However, it’s a great way to speed up your systems and meet nerdy colleagues.

Table Tuning

Table tuning isn’t talked about very often. Why would you change the schema of a table for performance? Isn’t it usually done only for new features, or to add data integrity?

The reason is that your table schema can dramatically change how your queries behave. Consider these two examples, which can be used for the exact same application:

Let’s say the table had 1 million rows. The first table would need 197MB for the clustered index. It also needs an additional 2GB for the images being stored as LOBs. The second table would need 107MB for the clustered index, and nothing else. That’s a space savings of over 95%.

I’d recommend the following approach:

0. Make sure it’s safe to redesign your tables. That means making sure stored procedures are used everywhere, or views, or you have agreement from the folks working with the ORM tools you have.
1. Redesign the largest tables first.
2. Resign the tables that have the worst blocking or deadlocks.
3. Redesign ‘core’ tables. If a table is involved in over ~20% of your application’s queries, it’s a ‘core’ table
4. Redesign anything else.

Pay attention to the elephant in the room

Fix the obvious first

There are some great resources on table design. My favorite starting point, however, is Kimberly Tripp’s blog post on GUIDs.

 

 

 

Summary

The Good: Great performance improvements are possible (5x-100x is very achievable). Space savings come along as well.

The Bad: Development teams can be busy and tiring. There is a medium amount of development risk. If you don’t have a good database developer, you could make things worse, and break your applications in the process.

I have no idea who that is...
The Ugly: That application that is using LINQ to SQL on 1000 active spids against your lone OLTP database? It’s still there, even if the queries finish faster.

→ 2 Comments

Posted in Architecture, ORM, Performance Tuning