According to Baseline Magazine, you should make room on your bookshelf for the following books:

1. Managing the Human Factor in Information Security: How to win over staff and influence business managers by David Lacey
2. Information Nation: Seven Keys to Information Management Compliance by Randolph Kahn, Barclay Blair
3. The Truth About Middle Managers: Who They Are, How They Work, Why They Matter by Paul Osterman
4. Strategic Project Management Made Simple: Practical Tools for Leaders and Teams by Terry Schmidt
5. Growing Software: Proven Strategies for Managing Software Engineers by Louis Testa
6. Identifying and Managing Project Risk: Essential Tools for Failure-Proofin​g Your Project by Tom Kendrick PMP
7. The Greening of IT: How Companies Can Make a Difference for the Environment by John Lamb
8. Winning the Hardware-Softwa​re Game: Using Game Theory to Optimize the Pace of New Technology Adoption by Ruth D. Fisher
9. The Deciding Factor: The Power of Analytics to Make Every Decision a Winner by Larry E. Rosenberger
10. Manage Your Project Portfolio: Increase Your Capacity and Finish More Projects (Pragmatic Programmers) by Johanna Rothman

Once I stumble across a list like this, I’ll likely read a couple… already ordered one of them.

It appears the word/verb “Refactor” is absent “out of the box” from all if not most of the environments that provide a spell checker service or feature.  At least the ones I’ve used lately and since I started to notice.  From (this) Live Writer to Word to within the browser on the update textbox of twitter, you name it, I keep having to “right click, Add to Dictionary”.

Wikipedia does have an article for the term “Refactoring”, and so does Dictionary.com but the “verb” Refactor is not on either (Wikipedia redirects to Refactoring) and Merriam-Webster comes up empty when searching for either.

Is there a way to carry around one’s dictionary from environment to environment and use it on all if not most of the aforementioned tools? 

I guess I have to do a little bit of research, and no I won’t hold the post until I do.  I’d rather note my observation and I *should* then later do the legwork and update with my findings.  I reserve the right to slack on such task, do nothing and instead keep “right clicking, Adding to Dictionary” as I go.

Image by hisks

If you take the approach to clean up after yourself as you progress through whatever maybe your daily routine, and create this good habit for everything you do, you’ll end up avoiding what is almost unavoidably natural for most of us: procrastination.

Whether it is while you cook, write code/implement software solutions, do the laundry or go though things on your desk at the office, if you let things pile up… well, you’ll end up with a pile of <insert appropriate noun here>.

Why not keep your projects, solutions, classes, layers, frameworks, third party components et.al. in an organized manner right off the bat?  Regardless of the size and scope of the project, platform or technology…  Why wait until it becomes a tangled mess of bad historic legacy waiting… clamoring for someone to come in, criticize, refactor and “waste time” cleaning up your mess?

Why wait until your roommate, spouse, parent or sibling comes around and has to deal with piles of dirty dishes, filthy counters or messy bathroom?

I believe it is one of the easiest forms of procrastination to avoid with the highest payback in quantity, quality and immediacy of satisfaction.

Be it with the proverbial or actual dirty dishes, don’t be a slob, love yourself and those around you and Clean as you go… whatever that may end up being.

This literally just came into my inbox… (cut edited for obvious reasons)

And what exactly am I supposed to do with this?

If we keep having to include copy like this one, without making basic assumptions, I can't help but realize we are in deep trouble...

Via Jeff Attwood's post, in summary (because his posts tend to be very, hmm, thorough):

The primary improvement here is that we're only accepting a whitelist of known good URL characters. Allowing arbitrary random characters in URLs is setting yourself up for XSS exploits, and I can tell you that from personal experience. Don't do it!

We only allow certain characters to "end" the URL. Ending a URL in common punctuation marks like period, exclamation point, semicolon, etc means those characters will be considered end-of-hyperlink characters and not included in the URL.

Parens, if present, are allowed in the URL -- and we absorb the leading paren, if it is there, too.

The regular expression is:

\(?\bhttp://[-A-Za-z0-9+&@#/%?=~_()|!:,.;]*[-A-Za-z0-9+&@#/%=~_()|]

I love these as a quick, hands on way (my favorite) to get up to speed with skills and technology you may otherwise miss or take longer to catch up to.

Here is the training kit from the horse’s mouth:

The .NET Framework 3.5 Enhancements Training Kit includes presentations, hands-on labs, demos, and event materials. This content is designed to help you learn how to utilize the .NET 3.5 Enhancement features including: ASP.NET MVC, ASP.NET Dynamic Data, ASP.NET AJAX History, ASP.NET Routing, ADO.NET Data Services, ADO.NET Entity Framework, WCF 3.5 SP1, and the .NET Framework Client Profile.

Download the kit from here.

this includes most of those on facebook that don't quite get what its about.

follow this simple decision tree:

I know I have mentioned it before that one of my passions and (at one time at least, for sure) addictions are books. 

Yes, sometimes I read them!

Right now I am going through Working Effectively with Legacy Code and the less technical yet incredibly relevant but certainly more entertaining Dreaming in Code.  I'm trying to get through the former while at work, 30 minutes a day of reading when I can, the latter I am reading at home after the ripples of the hustle and bustle of what is my day to day at home come to rest.  At this point I'm at about the half way mark on both, but doing more reading at home than I am at work.

Michael Feather's book has been recommended so many times in so many different posts that I had to see for myself why this book was in those reader's opinion such a must read.  Jeff Atwood has it as part of his recommended reading list, Steven Smith posted a short review and recommendation after reading it as a recommendation from Jeffrey Palermo. For the fear you may have at this point that I post more references, I am pretty confident you get my point and trust my word!  Its been read and deemed a worthy resource.

At home I am also reading Ship It for a second time and just recently went over Practices of an Agile Developer for a third time as well.  To me both of these seemed [now] to be elementary, but yet so relevant, giving me a sense of "yeah, we are doing this the right way" and not because the books say so (hey, don't jump to conclusions), but because much of what is common sense extracted from the content of these compilations of ideas, past experience and the analysis of the results of their implementations, can be easily projected and extrapolated to the work we do, the way we do it and most importantly the way the people I work with have "learned" to relate, work, communicate with each other. 

I don't want to digress too much, but there is value in mentioning all this because most of these practices are part science, part common sense, part keeping your head above the smoke someone or some group in the industry is blowing at some point in time and at every turn.  It takes determination, self awareness and more importantly it takes focus to be able to weed through so much jargon and so much hype to extract what is really of value and what yield results.  On that last point, what yield results is always a combination of some elements from "all of the above" with what works for the group, for its dynamic for its internal makeup of skills, personality, culture & traditions.  Dare I  forget to mention keeping the business needs as a primary focus at all times.

Ok, so I did veer off a little bit too far, but what is done is done!

In summary, the message I wanted to convey with this post is that one should read not only to learn the "technology du juor", which of course is a perfectly valid reason to do so, but also and most importantly after reading so many opinions and different points of view one is able to apply these to a practical everyday life as a professional developer (in this particular case), how one then may use the same books one used to learn to now assess our level of assimilation of all this information, to gauge, to extrapolate, to connect one's own dots.

As I had previously mentioned, yesterday I attended the ArcReady event titled: Architecting for Scalable and Usable Web Applications.  Here is my summary notes, and brief opinion in a format as condensed as I could possibly make it and still do it justice to include all the goodies.

The morning was split in 2 sessions, the fist of which was presented by Larry Clarkin and the second by Technology Evangelist John Weise.

Session 1 - Architecting for Scalable Web Applications: Overall outstanding for many reasons but more importantly because it did not carry a [heavy] Microsoft Agenda.  It was participative, well focused, well presented and what I would consider appropriately "architectural" in content.  With a few practical tips, approaches and case studies presented it had enough of a take-away to raise it above a purely academic level typical of most presentations.

Premise: Scalability <> Performance.  Strive for stable Cost Per Transaction.  Don't expect Economies of Scale to apply to scalable web applications.

Doing some follow up research I came across this very interesting and relevant white paper by Kanwardeep Singh Ahluwaliaon Scalability Design Patters (PDF Download).

The Patterns for Scalability presented were:

• Be aware of the environment both physical (infrastructure/backbone), as well as configuration related: Look at configuration settings to make sure Debug is turned off (yeah, it happens).  Use the deployment element retail="true" setting.
• Scale UP Hardware: Look at upgrading RAM, Disk I/O and even CPU. 
• Scale UP Software: The concept of scaling up applies to Software as well.  Consider upgrading to IIS7 on Windows Server 2008.  Look to eliminate single points of failure by implementing solutions like Active/Passive and Failover Support.  Look at configuration settings to make sure Debug is turned off (yeah, it happens).  Use the deployment element retail="true" setting.  Manage your sessions!  Consider turn them off for the application and on as needed per page.  Evaluate your needs for InProc vs. Database sessions.  Set them accordingly.
• Scale Out: Solutions include DNS round robin, Microsoft's Network Load Balancing, Microsoft's ISA and hardware load balancing solutions by vendors like Cisco.  As with anything else the right solution will depend on your needs, environment, budget etc.  Pay special attention when using load balancing solutions and SSL, remember to set affinity.
• Specialize: Use a node/server/group per role/responsibility: Web (UI), Application (Web Services, etc), Resources.  This last one was a good eye opener. Static in nature, resources make up most of the payload in a typical request.  A good case for implementing IIS7 configured with just the modules required for static content.  This would yield a significant performance gain.  You will also gain from "decoupling" the hosting implementation and can make adjustments where needed without affecting the rest of the solution.  Consider using 3rd party services to offload static content.
• Split the Application: Consider using subdomains if you can logically and functionally split your application.
• Split the DB: From a "logical" unit(?) point of view.  First approach under this pattern tells us to consider using a separate database for Reference & Transaction data.  A quick downside effect of this approach is that we violate many-a-rule of normalization and risk breaking our otherwise good relationship with our DBAs because of that! <grin>.  A second approach under this bullet points us to a solution that calls for Read & Write versions of the data.  One write, many (as needed) write versions.  Use appropriate synchronization/replication between them.
• Database Sharding: I knew of this approach referenced by the term Partitioning rather than Sharding, but the concept is to split your DATA across databases based on a given criteria inherently part of the data, like users with last names from A-D on one database, E-H in another one and so on... or split it by department or like apparent MySpace does it, one database by X amount of users which in their case appears to be 1,000,000.  To overcome the challenges inherently part of trying to manage data spread according to this approach, you can leverage technology like Distributed Partitioned Views available in SQL Server.
• GEO distribution: With more specialized uses and needs, typically used to increase availability by proximity and to provide some redundancy and failover.  Requires you to have or leverage Hardware and infrastructure knowledge skill and expertise.
• Offload the Work: Examples include services like Flickr picture hosting (applicable only to personal use), and Silverlight Streaming services.

Anti-Patterns:

• Spending all your time looking at your code (as your bottleneck)
• Caching everything <-- Do cache, but do so judiciously.  Caching chews up resources which hurts scalability.
• Services calling Services.

I truly enjoyed the presentation, the format, the tone and the content.  It wasn't better only because sadly it was cut short.  The last 20% of the content was pretty much delivered in 20 minutes which was a pity because the conversation was flowing and the attendees were engaged.

Session 2 - Architecting for Usable Web Applications:  John Weise breezed through some slides with too much of the content being "more of the same".  There were some interesting points brought up and the Demos where simple and short "show and tell" for a couple on "cute" applications.  Nothing breathtaking or groundbreaking there.  He talked about (showed) the UI Archetypes and went into some detail over the UX Continuum as part of which Larry stepped in to talk about and show the UX IQ application.  This cool little application is provided as a tool to provide guidance on application platform selection.

Best Practices:

• Form Follows Function
• Create a set of design tenets
• Use the appropriate level of fidelity
• Build with the customer and user's input <-- From agile?
• Build for ease of use, but don't forget the Power User.
• Plan for concurrency
• Balance security with usability
• Build for supportability and maintenance
• Be aware of standards <-- Compliance

Anti-Patterns:

• Golden Hammer
• Breaking UI conventions
• Overuse of animations

My personal opinion and take-away out of this second session, was not as positive as for the first part, but I still got some good pointers, and overall the time spent was well worth it.

Three good demos worth mentioning:

• ProtoXAML : Prototyping UI, with napkin skin... awesome!
• UX IQ <-- Couldn't find source at fist pass, will look further and update when and if I do.
• Woodgrove Financial WPF application.  Source code here.

As part of the now common and to a certain degree expected give-away, books and copy of Office 2007 Ultimate where handed out. 

Two of those books are available online and as PDFs for free:

• Improving .NET Application Performance and Scalability
• Performance Testing Guidance for Web Applications