Meeting Etiquette

One of the things I really got ingrained in my habit while working at Bank of America was the respect of other people’s time.  Especially in fast moving projects this is a very important thing to practice.  While working at BoA one could literally be let go if they did not respect other people’s time when scheduling meetings and other such time consuming, yet much needed, work related events.  I was digging around some material I had found in storage a few weeks ago and it got me thinking about this.  The core facet of this trait is simply, “respect other people’s time“.  Everything about one’s work habit within a team should encompass this.  The core idea behind this trait is, “empowering the individual” and is simply part of a “meritocracy” based environment.

  • Don’t be late to a meeting.  Not even a few seconds.  The only acceptable arrival times is at the scheduled time or before.
  • If you’re going to be late notify well before the meeting and be sure to give an ETA so an accurate rescheduling decision can occur.
  • Make sure to send any notices for a meeting well in advance of a meeting.  (2-4 hours minimum)  Otherwise expect nothing more than a quick conversation of 5 minutes or less.
  • Take into account other people’s meeting schedules.  Don’t double, triple, or otherwise book people.  Even if you’re the boss, don’t do this without notifying the person of their priority, or asking what their priorities are for the day.
  • Make sure to have clearly defined topics and understand the objectives and goals of the meeting.  Do NOT go to a meeting and just start conversation on a “cloudy” or unclear topic.
  • Do not surpass the scheduled meeting time.  If you think you need time, schedule as much of it as you believe will be needed to cover the topics.
  • Preferably take meeting minutes and designate a specific individual to meeting minutes.
  • Make every attempt to stay on topic during a meeting.  If one leaves topic, have a designated topic watcher to maintain the flow of the meeting (the meeting minutes person usually is good at this).

Those are the summarized meeting points for the material I found.  I’ve blogged because I think this is a highly underrated trait, often unnoticed these days, and even more so unnoticed on the west coast for some reason.  However the amount of productivity lost to non-punctual, unscheduled, off topic meetings is massive.

kick it on DotNetKicks.com

del.icio.us Tags: meet, meeting, productivity, meritocracy, merit, individual, empowerment, empowering, respect, people, bank of america, trait, habit

Technorati Tags: meet, meeting, productivity, meritocracy, merit, individual, empowerment, empowering, respect, people, bank of america, trait, habit

Database Standards

I’ve been on a run about coding standards lately, reading about them, figuring out which to follow and which to not follow.  Well one thing I had not been looking at much was database standards.  I realized I had a bunch of questions;  how do you name tables, according to what schema, are views concatenated names correlated to their respective tables, do stored procedures have verb noun correlation, do functions get named similar to stored procedures, do we prefix database objects with shortened abbreviations and such related to what they are?  Well I’ve started keeping a list of things I’m starting to prefer when designing and building a database.  Enjoy…

Database Standards :: Build 0.01

  1. Table Names should be named to a singular of the data object they hold.  At least when utilizing a domain or business object pattern approach to development, for readability of generated code (yeah, a standard based on generated code!) tables should be named singular.  Examples would include;  Car, Bike, Train, or if one had more granular break downs Wheel, WheelType, WheelTire.
  2. Database objects should use casing just like code objects.  So if there is a Car Object that has Wheel Objects and a Wheel Type Structure the tables in the database should be named accordingly with the same casing;  Car, Wheel, WheelType.
  3. Artificial name spaces should be setup for database objects.  If a table is directly related to a particular table, such as a Wheel having a type in the WheelType and a tire type in the WheelTire table, each should be prefixed as written here with Wheel.  This assures easy visual coordination of tables that are closely related via domain logic, business logic, and via referential relationships within the database itself.
  4. If one goes with the base table pattern (similar to using base classes) and sets up a base table to hold vehicle information the base table should be post-fixed or pre-fixed to the associated tables.  Thus we would have VehicleCar, VehicleTrain, or VehicleBike based off of the Vehicle base table.  The reverse would look like CarVehicle, TrainVehicle, and BikeVehicle.  I prefer the fore-mentioned naming convention but the later convention is more readable in my opinion.

So far, that’s what I got.  If I get to deal more with database standards I’ll definitely post them here.  Anyone else have ideas, notions, arguments, or opinions on what should change, be added, or deleted?  Submit a comment.

kick it on DotNetKicks.com

Coding Tools Conflict With Old Coding Standards

WARNING:  This is not a jab at Lowy‘s Standards, I’m just picking on his stuff.  Smile [:)]  So don’t take it to heart, it’s just code.  Stick out tongue [:P]

So I’ve been creating tips o’ the day recently and I started reading through some of Juval Lowy’s C# Coding Standards.  I’m a follower of Microsoft’s & the Code Analysis/FxCop school of code creators.  I also tend to follow the idea that if it is generated, it should generate to specification with no bad code in there.  Sometimes I let things slide if the code base is really trustworthy, such as the Enterprise Application Blocks.  The reasons are long that I go by current code standards, the main reasons boil down to plain, cold, hard cash.

The simple fact is, if you don’t follow current standards it exponentially makes it more difficult to use all of the code generators, shortcuts (like ReSharper), and the legion of tools that are available for enhancing one’s ability to create good code.  While I was digging through Lowy‘s Coding Standards from IDesign I noticed a few standards that I have issue with.  If for any other reason than it costs more money, because it takes time to make changes to the tools, and thus, time is money.  Every machine one has to touch using standards that deviate from tool usage is lost time.

I know, I know, you’re probably thinking, “Adron!  How insanely obsessive compulsive!”  Yeah, well, I am.  It makes me good at what I do, it also makes me entertaining when I speak, drink, or randomly start conversations.  Let’s take a few examples just to prove my point.

In Lowy‘s Standards Document #4 is “Prefix private member variable with m_.  Use Pascal casing for the rest of the member variable name following the m_.“

public class SomeClass { private int m_Number }

The sample above is all fine and dandy, but seriously, why go old school C++ and use the m_ when one can just use the current Microsoft P&P Code Analysis/FxCop standard of just “number” or “someNumber”?  Because if you use m_, you have to alter your ReSharper template and when generating documentation it confuses some tools and in general, and when generating document it appears busy as if to add complexity where none is needed.

#20 is another item that just doesn’t really work.  It states “All member variables should be declared at the top, with one line seperating them from the properties or methods.”  This one I don’t have “that” much of a problem with, but there is a serious issue.  If you have a bunch of private members, do you know if you’ve created the appropriate respective public properly getter and setter?  Can you easily use the “prop” macro function that will allow you to generate the private and public property and all that is left is merely filling in the member name, type, and public property name?  Does it simplify what ReSharper does?  My simple rule of thumb is that you do what makes since for the file.  If you do heavy ReSharper and gen the properties then do split them as Lowy says.  But if you don’t have ReSharper than be sure to keep the private member with the public property it is for.  It is easier then to find your member and its associative property.

The last one I’m going to harp on is #10.  When doing Agile and TDD there is major emphasis that the tests are documentation.  “Use extensive external documentation for API documentation.” is somewhat counter to a live, actively changing, and readily maintained system.  I tend toward the TDD and tests are documentation approach because of the larger return on the investment developers get from this.  If the product is a software tool for other software purchasers, then yeah, create API documentation.  Otherwise keep a minimal amount of API documentation and test, test, test.

But I must say, in the end, the Lowy Standards document is some great stuff.  If you aren’t following extensive standards as he has laid out, his or Microsoft’s or whoever’s, it doesn’t matter.  To create great software one has to have good standards in place.  To have good change management and good process (Agile or otherwise) one needs good standards.

So hats off to Mr. Lowy, great job.  I just don’t agree 100%, but we wouldn’t be very good developers if we didn’t disagree on things sometimes.  Smile [:)]

kick it on DotNetKicks.com