Below are some pictures and a video I shot at the Expo. I’ll keep this post short, but I plan on attending the Expo again next year!

Believe it or not, the sales process has been relatively tricky. Although many small business owners are keenly aware of the benefits of a professional website, many others don’t seem to care. These people often manage their website themselves and are convinced that they don’t need an upgrade.

The sad truth is that your visitors do form an immediate opinion of your business when they see your website. This first impression can be the difference between gaining or losing a customer!

Without further adieu, I give you the five top reasons why your website sucks:

It Gives Me a Seizure

If your website uses more than 3 colors for its text, has animated GIF images, uses scrolling marquees or blinking text… your website sucks!

Let’s be honest here: your visitors are so overwhelmed by color and animation that they don’t know where to look. This isn’t good! If they can’t find the information they’re looking for, they’ll search for your competitors.

It Uses Frames

If your site uses the HTML tags frame or frameset… your website sucks!

Frames are about the worst thing you could use to build your website. For starters, search engines can’t crawl your content when it’s loaded inside an HTML frame element. Frames aren’t consistently rendered in every browser, so your website might look even worse than it already does. Frames confuse your visitors as the browsers “Back” button now does something different than expected. Frames don’t print as expected. Frames often cause scrollbars to appear. Frames are also a security risk to your browser.

If those weren’t enough reasons to avoid frames, consider this: HTML5 won’t support them.

Browsers Murder It

If your website doesn’t look the same (and work) across all of the Web browsers that (at least) 90% of your visitors use… your website sucks!

This is the hardest thing for do-it-yourself webmasters to understand: building a website is harder than you think. Things that look fine in Internet Explorer often don’t look the same in Firefox, Chrome, Safari or any of the other Web browsers available… and I haven’t even mentioned mobile devices!

It’s important to know what browsers most of your visitors use so that you can test your website and be sure it looks fine. If your customers think your website sucks, what will they think about your business?

It Doesn’t Tell Me Anything

If your website doesn’t give me the information I’m looking for… your website sucks!

Are your business hours listed? What about your address and phone number? What is it your company actually does?

The answers you need to provide may vary, but it’s important to give the public what it wants. Furthermore, your content needs to be well organized so that these answers can be easily found! If your customers can’t find the information they need from you, they’re going to check out your competitors.

It Uses Flash

If your website is heavily reliant on Flash… your website sucks!

Companies often ask about Flash because it looks cool. And it often does… but websites that rely on Flash to display important content have several serious failures.

First of all, many mobile devices can’t display Flash. The iPod and iPhone can’t display Flash at all – a huge problem given how many people use them.

Secondly, Flash isn’t easily indexed by the search engines. Google says it can read text embedded within Flash files, but regular HTML text is far easier for them (and the other search engines) to read and understand.

Lastly, do your visitors actually like having to wait for your Flash animations? Many websites that use Flash go overboard using everything from background music to animated page movements. Your visitors are looking for something specific – do you really want to make them wait for it?

What do you think?

Do you agree or disagree with this list? Did I miss anything?

Disclaimer: Mats granted me a free license to use the tool in exchange for my review.

After unzipping the source code, I poked through a few of the examples. At first glance I was very impressed! The download came packaged with six demos, each of which utilizes different ExtJS features and gathers data via different sources (eBay, Google Calendar, among others). My only immediate complaint was that the API documentation wasn’t included in the ZIP file. It is however freely available on the Ext Scheduler website here.

Let’s Build Something Fun!

Rather than just saying what the Ext Scheduler does… let’s build something! Since Ext Scheduler’s website already has a handful of examples, I’d like to try building something new — let’s use the Twitter API and map when our tweets are posted.

A quick note: I didn’t realize something important until I was almost done with this application – the Twitter API doesn’t allow you to grab tweets based on a given time frame. You’re only allowed to grab the last X tweets… which I think is pretty lame. Had I know that before starting this application, I would have chosen a better example. *Facepalm!*

My journey through the Ext Scheduler started with a quick look through the API docs. The basis for the entire application is the Sch.SchedulerPanel() class, which is an extension of the Ext.grid.GridPanel(). If you read the API docs for this class, you’ll learn that it depends on two data stores: the first (“Store”) defines the various categories/rows for your application, while the other (“EventStore”) defines the events displayed on our schedule.

For my sample application, the “Store” will consist of a single Twitter user and the “EventStore” will be filled with this user’s 50 most recent Tweets. Thus, my application only has one row on the grid (boring, I know). I chose to display my grid as a 24 hour day so we can see our user’s Twitter activity over the course of a single day. Toolbar buttons allow us to move forward/backward by day. (Since the Twitter API doesn’t take start/end date parameters, this functionality is somewhat pointless.)

Take a moment now and try my sample application. We’ll explore it in more detail below, but see the source code here.

Learning Curve

My only real complaint with the Ext Scheduler code is the fact that there’s a slight learning curve. The examples provided in my ZIP folder are great, but there’s so much going on in each demo that it’s hard to figure out the basics. It took me the better part of a day to get my application working, so be prepared for a little bit of frustration.

Don’t get me wrong – this is an awesome tool, and I had the same complaints about ExtJS when I first started too. As such, I’m hoping this review can be a step-by-step demonstration on how to get started.

Step One: Define Your Categories

The “CategoryStore” is used for our left-hand grid labels – the entities to which the events are associated. In some of the other Ext Scheduler examples, the “Categories” were often people; the “Events” were often meetings or other appointments.

I started my application by prompting the user for their Twitter username. If you open my source file, you’ll see that I take the user’s input and insert it as a new data record into my TwitterApp.Scheduler.categoryStore (an Ext.data.JsonStore()). That was easy!

Next, I call the init() method on my TwitterApp.Scheduler object (a generic literal), which calls a series of other methods. In essence, here’s what they do:

• Set this.start and this.end (values needed to properly display data in our schedule)
• Create and load our “EventStore” (we’ll come back to this in a moment)
• Create the scheduler grid and render it to the UI

Step Two: Define Your Events

As I just mentioned, we need to create and load the event data to display on our schedule. See the following code:

Our “EventStore” is another simple Ext.data.JsonStore() object; however, I’m pulling the data for this store from the Twitter API (based on the supplied username).

Take note of the “start” and “end” base parameters on this store. Although Twitter doesn’t really need them (which is why this example kinda sucks), the Ext Scheduler classes do! If you don’t add these parameters you’ll get an error!

When this store finishes loading (see my LOAD event), I manually set the “EndDate” property for each record because Ext Scheduler needs this information.

Step Three: Create the UI

Once we have our categories and events defined, we have the data we need to display the Ext Scheduler UI.

The Sch.SchedulerPanel() class is an extension of the ExtJS GridPanel(). The only things we really need to be aware of are the autoViews property and the eventTemplate since they’re the two things which really affect the appearance of our tool.

For the autoViews, you have your choice of displaying the grid by days/week, hours/day and a few other options. Since we’re using Twitter, I thought hours/day was most appropriate.

For the eventTemplate, it’s important to create an Ext.Template() object that means something to your users. Looking at the other examples of Ext Scheduler, you might see the name of the event, its start/end times, or other descriptive information. My example isn’t as cool… but you get the idea.

The only other thing I should point out is that your users will probably want a way to change the date range displayed by our scheduler grid. I added “Previous” and “Next” buttons which essentially alter the start/end date and reload our “event” data.

Step Four: Brag about your tool!

As I already pointed out, the Twitter API was a terrible choice for this demo because it doesn’t allow me to search for tweets by a selected date range. It was also a bad example because tweets don’t have start/end dates. Note to self: choose better examples next time!

Overall, my impression is that the Ext Scheduler will be an invaluable tool for most developers working with “events”. It’s easy to work with, offers an impressive set of features and should impress a lot of end-users. I would encourage everyone to check out the other Ext Scheduler examples and see for yourself!

Why is that a big deal? After all, there’s this prominent link saying “Upgrade” when WordPress (or any of the plugins) detect a new version.

Well… for starters, I’m hosting this blog on a Windows IIS7 machine. To complicate matters, I’m also using GoDaddy. Rather than diving into why either of these factors is complicated (if you’re interested, do yourself a favor and Google it) I’ll simply jump into the solution for automatically updating WordPress on a GoDaddy IIS7 hosting plan.

Step One: Login to GoDaddy

Login to your GoDaddy hosting control center.

See those tabs at the top? Hover over the “Content” tab, then click on the “File Manager” option.

Step Two: Set the Correct Permissions

Using the file manager, find the directory containing your WordPress blog and check the box next to that folder. (For example: if your blog is installed at /(root)/mysite/myblog/, then  navigate to /(root)/mysite/ and click the box next to myblog).

Click the “Permissions” button from the toolbar.

When the dialogue box opens, set the permissions for this folder to “Read/Write”. Be sure to also “reset all children to inherit” these permissions.

Click “OK”.

Step Three: Click the Automatic Upgrade links

Now, login to your WordPress dashboard. Click the “Upgrade” links for WordPress and any plugins which have new versions.

Be sure to properly backup your database and other files as needed!

Step Four: Reset the Permissions

Technically, you probably don’t have to do this — but it’s good practice to never allow applications extra security clearance when they don’t need it.

Simply follow steps 1 and 2 again, only uncheck the “Write” option. Be sure to “reset all children to inherit”.

Any Questions?

This worked perfectly for me, moving from v2.8.6 to v2.9.1. I’d love to know how this works for you!

ASP.NET 3.5 Application Architecture and Design was written by Vivek Thakur and published in 2008.

Who This Book is For

This book is intended for developers who have “basic understanding of the ASP.NET framework, and programming knowledge of either C# or VB.NET”, although it looks to me as if every example is written with C#. The word basic is a relative term, but Vivek seems to use it accurately – you don’t need to know that much about ASP.NET in order to comprehend this book.

Furthermore, Vivek states that “if reading about application architecture usually confuses you or sends you to sleep, then this book will be perfect for you!” He’s not lying. Vivek does an outstanding job explaining complicated concepts using everyday analogies.

Getting Started

Vivek starts the book by introducing the reader to the world of software architecture. He uses the analogy of an automobile company, where mechanical engineers, design engineers and the assembly line staff all have clearly defined roles – roles separated from each other for a variety of reasons. Vivek equates this process to that of the software “project life cycle”, and then moves into a discussion on software tiers and layers.

From there Vivek dives into n-Tier software architecture, giving some great examples along the way. I loved his approach to this topic because he starts at the beginning (a 1 Tier, 1 Layer application) and moves step-by-step towards a fully n-Tier application (his example uses 6 Tiers). The author also sticks to the same example (an order management system, or OMS) which helps the reader easily understand how a 1 Tier application is different from a 4 Tier.

I also really appreciated Vivek’s instruction on how to add new class libraries to Visual Studio. For readers who aren’t well versed in VS, this is definitely something useful.

Lastly, I thought it was a great idea to introduce the concepts of Data Transfer Objects (DTOs), Lazy Loading and distributing assemblies across multiple machines. Vivek’s explanations of each subject were clear and concise – perfect for readers with only “basic understanding of the ASP.NET framework.”

Moving On

About halfway into the book, the author moves into discussions of MVC and SOA design patterns. The only thing I really didn’t like was the introduction of the Windows Communication Foundation (WCF) in chapter 7, and that’s because Vivek only spent 4 pages on the subject. WCF is also the only .NET-specific topic in the entire book; I understand why it was introduced, but it felt rushed and (as someone who isn’t an expert ASP.NET developer) I didn’t get much out of it.

On the other hand, I really enjoyed Chapter 8 (Database Design). Vivek’s conceptualization of the domain model vs. the logical data model is spot-on, and I would recommend that any developer looking to build a database read it. I particularly liked the author’s example on page 197 for data normalization: who knew that the members of Metallica wrote books on ASP.NET? Sweet!

The Final Verdict

I definitely enjoyed reading ASP.NET 3.5 Application Architecture and Design. Overall, I think I would say that anyone interested in software architecture and design (regardless of the language used in development) could get a lot out of this book, minus a handful of exceptions (see my comment on WCF above).

Nice job Vivek!

Long story short, this particular client (a restaurant) asked me to add some new content to their menu. Rather than expecting the user to scroll down a lengthy list of mouthwatering lunch options, I suggested that we add tabs to the menu in order to logically separate the menu items.

Since I already had jQuery 1.3 running the slide-show on this website I simply decided to build the menu tabs in jQuery to maintain consistency. But I was suddenly struck by an idea: why not compare how ExtCore and jQuery UI create tabs from HTML markup!

ExtCore

ExtCore can be downloaded from the ExtJS website, and an online demo of the simple tabs can be seen here.

The first step to building tabs from HTML markup using ExtCore is to reference ext-core.js in your page header. You also need to include the tabs.css file and the “images” folder containing the necessary 5 background images. (These can be found under “/examples/tabs/” of your ExtCore download ZIP.)

Note: I’m using ExtCore 3.0, although I believe 3.1 is available for download.

Next, we need to add the appropriate HTML markup for our tabs. Here’s a quick example.

As you can see from the picture above, ExtCore takes a wrapping DIV element (class “tab_container”) and converts a nested unordered list into the tabs. Subsequent child DIV elements contain the markup for each tab’s content. (The source code in this example is taken directly from the ExtCore tab example.)

The only thing to notice is that each DIV element has a CSS class assigned to it – these classes are essential to proper tab theming. The DOM ID properties are used to click back-and-forth between tabs.

Lastly, you need to include a JavaScript snippet which converts your HTML markup into a fancy tabbed widget:

jQuery UI

jQuery UI has a tab widget which is dependant on the larger jQuery library. An online demo of their tab widget can be seen here.

The first step to using tabbed content with jQuery is to reference:

• jquery-1.3.2.min.js
• jquery-ui-1.7.2.min.js

Your file versions may differ (I think jQuery 1.4 was just released), but these are the versions I’m using. I’m also using the “smoothness” theme – for some reason jQuery UI would not allow me to download the package without specifying a theme. (That may affect my analysis for speed in the next section.)

You will also need to include the CSS file and images folder included with your download of jQuery UI. In my case, it’s jquery-ui-1.7.2.css and an “images” folder containing 13 background images.

Next, write your HTML markup:

Compared to ExtCore, jQuery UI expects less HTML markup as we lose several layers of nested DIV elements. The most obvious difference between jQuery UI and ExtCore is probably that jQuery UI doesn’t need the extra CSS classes applied to the DIV elements.

Next, we add our JavaScript snippet:

Again, jQuery UI expects less code to generate the tabbed widget.

A Deeper Look

Let’s take a look at the file sizes for each library. This is about as un-scientific a study as it can get; I’m using Firebug’s “Net” tab to grab file size and download speed numbers. These numbers will probably be different for you because of any number of factors… but you get the idea.

As I already mentioned, ExtCore requires 1 JavaScript file, 1 CSS file and only 5 background images:

• ext-core.js (78.9 KB, 156ms)
• Ext.tabs.css (1.3 KB, 147ms)
• 5 png files (2.8-2.9 KB each, average 107ms)

Combing the file sizes and their download times (on my home network), you get a total of roughly 94.7 KB taking 838ms.

jQuery UI requires 2 JavaScript files, 1 CSS file and 13 background images (again, with the “smoothness” theme):

• jquery-1.3.2.min.js (55.9 KB, 116ms)
• jquery-ui-1.7.2.min.js (188.1 KB, 221ms)
• 13 png files (22.3 KB total*)

*Something interesting I noticed about the jQuery UI tabs is that my page only seemed to load 5 of the 13 background images, totaling something like 605 bytes and a total of 684ms. Perhaps someone more familiar with jQuery can explain that to me… I didn’t dig deep enough to figure out what was going on, but I’ll base my total on what Firebug says. I’m guessing that I’m not using all of the CSS background images for this theme.

Overall, that brings jQuery UI tabs to a total of roughly 245 KB taking 1021ms.

What Does That Even Mean?

According to my inaccurate, quasi-scientific study it appears that ExtCore requires slightly more code than jQuery UI. On the other hand, ExtCore also appears to be downloaded by my browser more quickly than jQuery UI. In reality, those numbers probably offset each other as the extra markup required by ExtCore increases the HTML file size. The fact that I’m using a theme on jQuery UI probably also has a slight impact on performance.

Which do I prefer?

In essence, both libraries create tabbed widgets from the same basic HTML markup – though the differences are significant enough that they’re not cross-compatible.

Judging both frameworks as they stand in my examples, I will say that I like the conciseness (is that a word?) of jQuery with regards to both HTML markup and JavaScript code. But I also like that ExtCore requires fewer files. As someone who uses the larger ExtJS framework a great deal, I’ll say that I am very likely to choose ExtCore over jQuery UI most days of the week.

Are there any ExtCore or jQuery UI users out there? What do you think?

Over the past two years I have developed a number of websites for small businesses in my area. When I ask why they never had a website, the excuse I hear most frequently is that websites cost too much.

To be fair, many small business owners have a hard time finding the extra money to build a website — particularly nowadays with the bad economy.

So what are your options?

Option #1: Build the website yourself.

Domain names and web hosting are pretty cheap, and most personal computers come with do-it-yourself software. You own a business. Building a website can’t be that hard… right?

The problem with this approach is that you probably don’t know what you’re doing. Do you buy a Linux or Windows hosting plan? Do you need PHP or .NET support? Do you even know what HTML is?

Assuming you even get the website up and running… how can you be sure if it works in Internet Explorer, Firefox, Safari and every other web browser?

More importantly – will it look professional? Your customers will judge your business when viewing your website, so you definitely want to make a good impression.

Option #2: Contact a web design firm.

Web design firms obviously have the resources and experience to build your website. The problem is that they’re expensive. (Can you afford to spend $5000 or more right now? I definitely can’t.)

Web design firms have to charge higher prices in order to cover their operating costs (salaries, benefits, utilities, etc). They will also try to sell you features or services you don’t need; things like Flash intros, Search Engine Optimization, and a slew of other things. They’ll even charge monthly maintenance fees on top of their development costs.

Although it’s true that those extra services are worth something (Search Engine Optimization helps your website appear at the top of the search engine listings), the fact is that most small businesses don’t really them. Will a cool Flash video on your homepage make your customers say “Wow”? Maybe. Will that video influence them to buy your product or service? The answer is almost certainly “no”.

Option #3: Hire a freelance developer.

Freelance developers are often the best choice to build a website for your small business. We have the necessary experience it takes to write the code and the knowledge to help you make informed decisions. Our prices are much more affordable than web design firms because we have virtually no financial overhead.

Some freelancers even accept bartered services… it’s win-win! (Note: be prepared to offer something worthwhile.)

Some things you should consider.

At this point, you’re probably leaning towards hiring a freelance developer. But if you’ve never worked with a freelancer before, there’s a few things you should know:

• Freelancers won’t work for peanuts. Just because we charge less than design firms doesn’t mean you can get a quality website for $50. We are experts in our field, so expect to pay a fair price (or barter for equal services).
• Freelancers don’t work for you 9-5. Many freelancers have regular jobs, so be prepared to meet with your freelancer on nights or weekends.

What are your thoughts?

In case you haven’t figured it out yet… I’m a freelance developer! I’d like to think that I’m not too biased, but I want to know what you think.

Have you ever worked as a freelancer? If so, what was your approach to working with small businesses?

Have you ever hired a freelancer? If so, what was your experience like?

ASP.NET MVC 1.0 Quickly was written by Maarten Balliauw and published in early 2009. The book caught my eye as I’m currently working on a project using ASP.NET MVC and I decided I could probably benefit from reading this book.

Who This Book is For

This book is intended for “ASP.NET developers who want a fast-paced guide to building powerful web applications using the ASP.NET MVC framework.” I’ve been using .NET for a few years now, though admittedly I never learned Webforms. Although I consider that a blessing, a knowledge of Webforms is somewhat assumed in this book. All of the code examples are written in C# so you should be familiar with that as well.

Beginners may want to shy away from this book until they’re really familiar with web development concepts and know their way around Visual Studio.

Let’s Dig In

Chapter 1 discusses what MVC (model-view-controller) architecture actually is and dives into reasons why a developer may want to choose ASP.NET MVC over traditional ASP.NET Webforms. My only complaint about this chapter is that the author gives any reason to use Webforms. Yes, Webforms have a lot of built-in controls and event handlers – but let’s be honest, they’re not really very good tools. As a JavaScript guy, I’ll be the first to point out that you can develop data-driven solutions with frameworks like ExtJS that are cross-browser compatible and W3C compliant… plus your application will simply look better out-of-the-box.

Chapter 2 has the reader create a new MVC Application. Maarten shows us what a new MVC project contains by default (he calls it “inside the box”), which is a rather helpful introduction to ASP.NET MVC as it’s complete with screenshots from Visual Studio. I particularly like the “Employee” example, and Maarten does a good job showing the reader how the model/view/controller interact with one another. That being said, the author changes things in each class as the chapter progresses without highlighting or bolding the code sections which have changed – which makes it a bit hard to follow. Maarten also shows us how to build a Unit Test but doesn’t tell us how to run the tests.

The Train Runs off the Tracks

When I got into the third chapter, I have to say that I very quickly became frustrated with the author. Maarten says the following phrase at least 4 times in this chapter: “The examples in this section… can be found in the sample code for this book.” Translation: Go and download the code if you want to follow along, because I’m not going to explain what happens next very well. The book is less than 200 pages (not counting the appendices), and I really wish Maarten had simply pasted the code samples into the book.

I also felt like the author used too many customized examples (extending a built-in class to do X, Y or Z). I’ll agree that this kind of information is useful, but this approach forces the user to endure tangent after tangent. All I wanted was to learn how the MVC framework works – but the use of advanced examples prevents the reader from learning ASP.NET MVC 1.0 “quickly”.

Lastly, Maarten doesn’t talk about unit tests (one of the best reasons to use an MVC framework…) for most of the book. It’s mentioned in Chapter 2, but then we don’t hear about it again until Chapter 9. Personally, I think the author should have asked the reader to build a unit test for every example in the book – but maybe that’s just me.

Some Things I Did Like

Chapter 5 (Routing) had some useful information in there, specifically with regards to creating route patterns. I also enjoyed Chapter 7 (Using Existing ASP.NET Features), where Maarten explains how to use built-in ASP.NET features (like security, globalization, etc.) into an MVC application.

I’m mildly impressed that the author took the time to write Chapter 8 (AJAX and ASP.NET MVC) using jQuery in addition to ASP.NET AJAX. Good concepts, though Maarten again failed to tie any of this back into the previous 7 chapters.

Final Thoughts

I did get some good information from this book, and it’s probably worth reading if you want to learn ASP.NET MVC. I say “probably” only because I don’t know of any books which explain the concept more clearly or in a more organized fashion.

In my opinion, it would have been much smarter to have had the reader build a single application – adding features and parts as each chapter introduced a new concept. But Maarten Balliauw didn’t do that, and I think it really hurts the book. The reader is forced to jump from concept to concept, and not all of the examples follow the “best practice” for an MVC application – to separate functionality into complimentary models, controllers and views.

For example, Chapter 3 has a “Contact” model which interacts with the “Home” controller. There is no “Contact” controller in the author’s example, and we never actually create a view. (I take that back… it might be there in the book’s sample code – but I, like many readers, will never bother to download it.)

The biggest problem for this book is that it reads like a college textbook. It’s full of good information, but students want to learn by doing rather than memorizing definitions and abstract concepts.

Overall, I’d give the book a 3 out of 5 stars. Not terrible, but far from great.

* So says Dr. Chudler at the University of Washington.

For example, there’s me (Art). I played guitar in a garage band back in high school. I majored in Music at Loyola University Chicago, studying classical guitar. I also minored in Computer Science, and I work as a professional software developer. Beyond my highly coordinated fingers (from typing and plucking strings), I don’t know if I see an immediate correlation between the two areas… but I’m not a neurologist, so I won’t even pretend to offer an explanation as to why I’m good at both. I wouldn’t say that I’m necessarily awkward with my social or language skills, but I would say that I’m a terrible salesperson. Make your own conclusion.

Furthermore, almost every developer I’ve met has a similar story. And in addition to playing some kind of musical instrument, we all seem to be very productive while listening to music.

I have found that a good song puts me into a focused groove – like something just clicks inside my brain and the code writes itself. Complicated concepts unwind into simple solutions as if I can suddenly think in multiple dimensions.

In other words, I start working like I’m f*cking Mozart. Only on a computer. And waaayyy less famous.

The caveat, of course, is that a song isn’t long enough to maintain productivity like this. An hour (give or take) is ideal to generate some solid code, so finding an entire album (with no crappy songs) is almost priceless.

After giving this topic a good deal of thought, I’ve come up with the ten albums which I enjoy the most while writing code. The list is in no particular order:

Strung Out on Kid A (Tallywood String Quartet)
Kid A is probably my favorite Radiohead album. One of the coolest things about Strung Out on Kid A is hearing the different keyboard and guitar layers played by a string quartet. There’s also a bunch of different albums to choose from! If you like classical music, buy one – you won’t be disappointed.

Swordfish (Soundtrack)
Oddly enough, I’m not really a fan of trance/techno music. And I’ve never seen this movie. But this CD rocks. Paul Oakenfold does some really, really cool stuff.

Dark Side of the Moon (Pink Floyd)
Dark Side of the Moon is obviously one of the classic Pink Floyd albums. Smooth, a bit jazzy, and each track melts into the next. Simply brilliant. I will say that this isn’t my favorite Pink Floyd Album (I would pick Animals every day of the week), but you can’t lose with this CD.

Three Snakes, One Charm (Black Crowes)
I’m a big Black Crowes fan, but I might be alone in saying that this is my favorite album. It’s less produced than Shake Your Money Maker, but cleaner than Amorica. If you’re into pure Rock-N-Roll, this album is hard to beat.

Legend (Bob Marley)
The best thing about Reggae music is that it forces you to be in a good mood. It’s scientifically proven. Legend may be a best-of album, but let’s be honest… it’s the single greatest Reggae album there will ever be.

The Fragile (Nine Inch Nails)
As a double CD, The Fragile is a fantastic album to play while writing code as you get more than 100 minutes of pure awesome. The Fragile is by far my favorite NIN album… a fact that few NIN fans seem to agree with. The thing I love most about this CD: I hear a new layer or instrument every time I listen to it.

This is War (30 Seconds to Mars)
I got this CD for Christmas this year and I love it. Say what you want to about Jared Leto (I liked him in Requiem for a Dream), I definitely suggest you give this album a shot. It’s a solid set of songs that get you pumped up – and nothing helps you write code more some adrenaline. (Actually, not true. Caffeine does a pretty nice job…)

Across a Wire: Live in New York City (Counting Crows)
This is actually the only Counting Crows album I own – but it’s a fantastic CD. It’s a live performance that starts with a few of the band members playing acoustic instruments, but progressively adds electric guitars, drums and other instruments. Check it out.

Unplugged (Alice in Chains)
You can’t go wrong with any of the MTV Unplugged albums (Nirvana, Eric Clapton, etc). Alice in Chains gives the listener a totally different spin on their music, and it’s very cool to hear Layne Staley’s voice over the acoustic guitars.

Mellon Collie and the Infinite Sadness (The Smashing Pumpkins)
This was a tough call for me, because I could have chosen any Pumpkins album to put on this list. Mellon Collie and the Infinite Sadness is a double CD with a ton of variation; the instruments, tempo and dynamics change constantly, but it’s fascinating to hear how all the songs work together.

This list is far from complete – but I’m sure many of you will disagree with my selections.

What are your thoughts? What albums would be on your own list?

As 2009 comes to a close, it’s a good time to look back and see how well we stuck to our New Year’s resolutions. Although I’m sure that I am not alone, I will be the first to stand up and say that (yet again) I’ve failed to complete all of my goals for this year.

This blog has been a very useful tool to document the accomplishments (and failures…) that I have achieved – and documenting my New Year’s resolutions is just another way to help myself stay focused on what I find important. I suppose “important” is somewhat of a relative term; it would seem that I am constantly shifting my focus towards some new goal. Priorities shift up and down on the list, but I suppose that’s just life.

So how did I do in 2009? According to my New Year’s resolutions for 2009, I guess I did alright:

1. I did not learn Silverlight, and I’ll be honest and say that I probably won’t ever spend the time to learn it. I have come to terms with the fact that I’m a developer (NOT a designer) and thus Silverlight / Flash aren’t the best way to spend my time. I actually did sign up for a Flash class at the local community college, but it was cancelled due to low enrollment. I’m taking that as a sign from God.
2. I did redesign my website! Although I did briefly attempt to create multiple sub-domains and online demos, I found that the redesign helped bring in some extra work. I never got around to the other details, but I’m not convinced that I even needed them.

The question now becomes: “What are my resolutions for 2010?”

In 2010, I hope to:

1. Double the amount of freelance work I generated in 2009. This will be achieved by: spending some money on local advertising, continued networking with local web development companies, and possibly creating an email newsletter when I have a large enough client base.
2. Change my use of social media. I have already started to do this… but I want to use social media sites strictly as professional tools. I plan to limit my use of Twitter, LinkedIn and the wide variety of message boards I visit so that I only post professional (i.e. “useful”) content. Facebook is a notable exception – I like that it’s a network of friends, and I don’t want them all to think I’m a total square.
3. Give at least two professional presentations. I spoke at an LCNUG meeting earlier this year and I attempted to create an ExtJS user group for the greater Chicago area. I won’t say that either presentation was amazing – and I know that I can do a bit better.
4. Use more photos on my blog. Personally, I like blogs that have photos. I don’t know if you (i.e. my readers) actually care, so if you have an opinion definitely let me know.

If anyone else has suggestions for what you’d like to see me accomplish this year… I’m all ears!