WiBit Redux 26/05/2011: Kotter’s Model of Change for a Software Architect

A good software architect is almost impossible to find as they comprise of 1 part senior developer, 1 part visionary, and 1 part salesperson. Often times a developer is promoted to this position without the support of management and simply continues as a tech lead instead of a true architect. Other times this position is filled externally, where someone comes pre-programmed on how things were done at ‘fill-in-the-blank’, tries to dictate the new methodology only to be met with intense rebellion from senior developers.

So what is a poor architect to do? I recommend looking to my repurposed view of John Kotter’s Model of Organizational Change.

Kotter Model of Change for the Software Architect

 

 

 

 

 

 

Overcome Resistance
The first phase of getting a change or project kicked off is by simply overcoming resistance to the resulting change. This can be achieved in three simple steps.

1. Capitalize on Concern
Those in any position of value will be accustomed to the daily noise of concern from both ends of the organizational spectrum. Whether these are concerns resulting from a specific incident or an upcoming deadline, you can use this knowledge to kick-off the change during an environment of urgency.

2. Pick the Best
I can’t put this more simply, choose the best you can. Always. It’s a team that succeeds, not a rockstar. Part of getting people to agree is to have a likable personality and to advocate projects and change that are truly beneficial to everyone in the organization.

3. Set a Clear Vision!
This is the most important step in overcoming resistance. When a clear vision is not set, the team members may get bogged down in creating actionable items to produce and conflicting visions of the outcome may grow. Your job is to make sure that we are all looking to take the same hill and are marching in step with the same clear goal in mind. This is accomplished by preemptively creating clear and well organized requirements both at a high and detailed level.

Implement and Sustain
Now that you are prepared and ready, it’s time to move into the executing phase by implementing the project or change.

4. Get Sign Off
The quickest way for a project to fail or for a change to come to a screeching halt, is by a higher up pulling the ‘unapproved’ card. Once that happens, it’s a quick game over. Have your sales pitch prepared and take it to either management, a change management council, or steering committee. One way or another, make sure you knock the pitch out of the park and seal the deal.

5. Breakdown Project and Submit Requests
Most people required to complete a project won’t be active participants. They will tend to be ‘queue based’ workers and focus simply on pending requests they need to complete sorted by date due. It will be your job to break the project into smallest possible physical actions and submit each of them as formal requests will clear criteria for judging success and a specific due date. This way, each of those requests will be processed in the queue of the employee required to do the task and you can track progress. Most companies will have a system for submitting and tracking requests.

6. Celebrate Short Term Wins
Now that the project has been broken down into small parts, there will be little obstacles and successes. Make sure to celebrate the short term wins as much as possible. This keeps everyone motivated, valued, and interested in the success of the larger project or change.

Integrate into the Organization
Sustaining the change is just as important as enacting the change. If the project is complete but not supported by the organization, it will be considered a risk and unsustainable. The easiest way to deal with something that is risky and unsustainable is to sunset the change or project. We don’t want that to happen. It is now time to integrate what we have built into the organization.

7. Never Let Up
Once the project is complete, find ways of documenting each persons role required to support the change and communicate this requirement as a duty of that position. Make sure this documentation is in the new employee intake workflow as well.

8. Make Sure to hit Deadlines
You must hit deadlines so that resources can be reallocated back to their ‘natural’ duties. This will not only help you to persuade upper management to sign off on the next project but also to transition people into a support role for the completed and lasting change.

Now go out there and get things done.

—Bryan

WiBit Redux 31/10/2012: Database Sandboxing to Increase Performance

Due to our site redo we lost our old blog!  Not to worry, we’ll re-post some of our favorites here over time :)  

Keep in mind some of the formatting or special stuff may be messed up, but the basic blog post is here.  Enjoy!

Sandboxing is one of those widely used I.T. buzz words. In some circles of software developers this word is on par with other common business buzz terms like “Synergy” or “Innovation”. If you are a developer then you have no doubt heard this term used in multiple facets of software engineering. It is often used in describing a development vs test vs staging vs production environment. It is also used to describe generic isolation. Isolation takes many forms such as networking (subsets of users can only access resources on Network A and not Network B), application execution (application can only access a subset of assigned computer resources), or server side development (which is the topic of this blog). Some of us resisted this idea, but in the end it is hard to argue against it. It’s one thing to sandbox application code, but what about server side?

A very exciting niche in software engineering is server side development. You get so many opportunities to work with many different technologies, and you also learn SO MUCH about integrating systems. One of the many exhilarating aspects of server side development is controlling the data! In today’s development world applications are often simply a shell to display data that comes from a server. This means that server side software development is more important now-a-days than it has ever been previously. People are so spoiled with peek performance from companies like Google that it leaves very little tolerance for applications to lag! The modern view of development is very server focused. The client side is important too, don’t get me wrong, but client software is heavily depend on the data resulted from the server. Any inefficiencies on the server will show on the client, and users will grow tired of significant lag very quickly!

Highly integrated applications, like Facebook, Twitter, etc have more complex methods of dealing with massive amounts of data. But a more simple application can use simple server side sandboxing techniques to maximize performance. If your application is company based, and the companies do not need to have highly integrated interactions with each other then one simple method of increasing server performance is to sandbox each company in its own database! This can be done automatically and it can be part of the account creation process.

Many applications store user credentials. Let’s say you have a table called [authorize], and it contains basic information about your users such as Company foreign key, User primary key, first name, last name and a SHA1 hash of their password. This table is queried when users request a login to gain access to the application. The table looks like this:

PK_UserFK_CompanyFirstNameLastNameSHA1PasswordHash11BillSimpson356a192b7913b04c54574d18c28d46e6395428ab21AllanSmithda4b9237bacccdf19c0760cab7aec4a8359010b031KimItzi77de68daecd823babbb58edb1c8e14d7106e83bb41BobBobson1b6453892473a467d07372d45eb05abc2031647a51JohnMcClainac3478d69a3c81fa62e60f5c3696165a4e5e6ac461LizSampsonc1dfd96eea8cc2b62785275bca38ac261256e27871IrisBliss902ba3cda1883801594b6e1b452790cc53948fda81ChrisRossfe5dbbcea5ce7e2988b8c69bcfdfde8904aabc1f91RandyMoss0ade7c2cf97f75d009975f4d720d1fa6c19f4897101RobertGriffinb1d5781111d84f7b3fe45a0852e59758cd7a87e5

Looks like a simple table right? This could easily be one of dozens (or even hundreds) of tables in a database that contains relationships to different database objects all over the place! Let’s say you have an application that has many companies sharing the same data source. After another company joins your [authorize] table will start to look like this:

PK_UserFK_CompanyFirstNameLastNameSHA1PasswordHash11BillSimpson356a192b7913b04c54574d18c28d46e6395428ab21AllanSmithda4b9237bacccdf19c0760cab7aec4a8359010b031KimItzi77de68daecd823babbb58edb1c8e14d7106e83bb41BobBobson1b6453892473a467d07372d45eb05abc2031647a51JohnMcClainac3478d69a3c81fa62e60f5c3696165a4e5e6ac461LizSampsonc1dfd96eea8cc2b62785275bca38ac261256e27871IrisBliss902ba3cda1883801594b6e1b452790cc53948fda81ChrisRossfe5dbbcea5ce7e2988b8c69bcfdfde8904aabc1f91RandyMoss0ade7c2cf97f75d009975f4d720d1fa6c19f4897101RobertGriffinb1d5781111d84f7b3fe45a0852e59758cd7a87e5112AlRotsman17ba0791499db908433b80f37c5fbc89b870084b122BethanyBell7b52009b64fd0a2a49e6d8a939753077792b0554132KwikiIslanbd307a3ec329e10a2cff8fb87480823da114f8f4142JohnRigginsfa35e192121eabf3dabf9f5ea6abdbcbc107ac3b152ShazamShwingf1abd670358e036c31296e66b3b66c382ac00812162ZackGroff1574bddb75c78a6fd2251d61e2993b5146201319172EmilyDeckerson0716d9708d321ffb6a00818614779e779925365c182LindaHamlet9e6a55b6b4563e652a23be9d623ca5055c356940192YolandaQuitzb3f0c7f6bb763af1be91d9e74eabfeb199dc1f1f202RavindraRumar91032ad7bbcb6cf72875e8e8207dcfba80173f7c

You can see that there are two different companies using this table and each company has 10 users. This is not big deal, right? Well., what happens if your application gets really popular and over night 1,000 different companies sign up. What if each company has 10,000 employees? Now this table contains 10,000,000 records. If this is only one table that contains data (which inevitably it will be), then that means each table starts to get overloaded with tons of data! Each time a new company joins and adds their employees the side effect is that every other company will experience more and more lag as it takes longer and longer to extract data from the database.

Yikes! This is a real problem. After you analyze your software you realize that the cost of rewriting it will severely affect your profits (because time is money), so you make the logical choice: increase the hardware! GIVE IT MORE RAM! GIVE IT MORE MEMORY! GIVE IT MORE SPEED!!!

Then, you get more and more clients… Your hardware cost cuts deep into your profits and you come to the realization that you need to increase your prices to make a profit. Your customers won’t like that, will they? Internet customers are used to either free or very low cost services so a price increase could cost you your entire business!!!!!! At this point, you may be forced to consider a rewrite.

Don’t kill yourself over this! If your application is focused on different companies, and the companies are not highly integrated, then consider this idea…
(RootDatabase)
[Company] 

PK_CompanyNameDatabaseName

Inside of a database called [RootDatabase] (in this example) there is only one table. It contains basic information about the companies plus and a database name. In your server side code you can create a database when a company creates an account and all the tables in that database belong only to that company. This keeps the root database very light weight because there is only one simple record for each company.

After 2 companies sign up your database will look like this:
(RootDatabase)
[Company]

PK_CompanyNameDatabaseName1Company ACompanyDatabase12Company BCompanyDatabase2

When each company creates an account, the two databases (CompanyDatabase1 & CompanyDatabase2) will be created automatically.

Your database server will look like this:

(RootDatabase)
[Company]

(CompanyDatabase1)
[Authorize]

[UserBlog]

… other tables

 

(CompanyDatabase2)
[Authorize]

[UserBlog]

… other tables

Neat and organized!

How exactly do you do this? Well, let’s say you are using PHP/MySQL on your server… part of the account creation process will run code like this:

{syntaxhighlighter brush: php;fontsize: 100; first-line: 1; }$conn = mysql_connect(“localhost”, “mysqlUsername”, “mysqlPassword”); $result = mysql_query(“SELECT COUNT(PK_Company) FROM Company”); $companyCount = mysql_fetch_row($result)[0]; $newCompanyDatabaseName = “CompanyDatabase” . $companyCount; mysql_query(“CREATE DATABASE ” . $newCompanyDatabaseName); mysql_query(“INSERT INTO `Company` (Name,DatabaseName) VALUES (‘$companyName’,’$newCompanyDatabaseName’)”);{/syntaxhighlighter}

The above code is incomplete, does not protect against SQL Injection, and I didn’t actually test the above code, but you get the idea! It’s very easy to do this.

As you can see… sandboxing your server side is a fantastic idea when you are dealing with massive amounts of data and you want to make sure your clients get the best performance possible! Now, the size and activity of one company has significantly less impact on others. Even simple things like removing the need to check a company foreign key will save valuable milliseconds or seconds or minutes depending on the table capacity! If you are selecting all of the blogs a company has submitted, then this query…

{syntaxhighlighter brush: sql;fontsize: 100; first-line: 1; }SELECT * FROM UserBlog WHERE FK_Company=1{/syntaxhighlighter}

Will technically run slower than this one…

{syntaxhighlighter brush: sql;fontsize: 100; first-line: 1; }SELECT * FROM UserBlog{/syntaxhighlighter}

… assuming the table is filled with hundreds or thousands of different company data!

Is there a limitation to this approach? Well, yes… Many DBMS application have a maximum number of databases that can be created. For example, SQL Server and MySQL typically max out at 32,000ish databases. But my view is… If you have 32,000 paying customers then that’s a good problem to have, and with the money you’re making you can expand to an array of SQL Server instances!

My guess is that if you are a database purist you hate this idea. And that’s cool if you do! I have seen this concept work before and I admit I do like the idea. I’d love to hear your thoughts, comments, complaints, rebuttals, etc!


Happy Coding!

Announcing the new WiBit.Net

Last night we started sending out an email to all of our users from back when we used Drupal letting everyone know that we’ve rebuilt the site. Here is the contents of that email:

Hello old friends and members of WiBit.net:

Over the past year we’ve been making big changes to WiBit, and we’re excited to have finally implemented those changes. We’re writing you today to let you know that we haven’t just changed the site, we completely rebuilt it! With advancements in mobile and browser technologies over the past few years we saw an opportunity to take what was good about WiBit and make it a whole lot better by improving performance and stability.

We’d like to invite you to come back and give the new platform a look! Check us out in Chrome on Android, Safari on an iPhone, or on your desktop web browser (we recommend Chrome ;)). For those of you who’ve already finished the courses check out the labs or the new quizzes to test your knowledge!

Major changes to WiBit.Net include:

Basic (free) full access to all current courses.

  • Intro to Computer Programming
  • Programming in C
  • Programming in C ++
  • Programming in Objective-C
  • Programming in Java
  • Course progress chart documents course completion rates

Sponsor and Corporate Membership levels

  • Ad free environments
  • Mobile access
  • Labs to solidify techniques and enhance understanding
  • Quizzes to test learned skills
  • Open access to all current and new course libraries

Corporate Membership also includes

  • Unlimited company users
  • User management tools
  • Detailed reporting tools to monitor individual usage
  • Option to replace WiBit.Net with your Company logo
  • Removal of social media links

tl:dr: we’ve made a lot of changes to the site, we’d like you to take a look.

Without you we couldn’t have kept the site going, and we wouldn’t have had the opportunity to make it better. We want to thank you for that, and invite you to review the changes and give us feedback on what you’ve inspired. Thank you again for all your support and we look forward to bringing you even more WiBit in the year ahead.