The Myth of Sloppy Code

  • Tightly coupled code runs faster.
  • Tightly coupled code is easier to write.
  • Test Driven Development increases development time.
  • Test Driven Development negatively impacts code design.
  • Knowing the names of design patterns isn’t important as long as you can use them.
  • All my customer cares about is how soon they can have the product, not how clean the code is.

All of these statements, and others like them, are excuses for not writing code correctly.  And you know what an excuse is, right?

The skin of a reason stuffed with a lie.

The Myth of Sloppy Code
Photo credit: dynamosquito via / CC BY-SA


Continue reading “The Myth of Sloppy Code”

Revisiting The Technical Interview

I’ve written about the technical interview before.  I’ve written both for and against code interviews.  And I’ve provided both C# and JavaScript questions to weed out fake programmers. But a little more experience under my belt has me rethinking what makes a good interview.

Now, you may wonder why I think I’m particularly qualified to speak about the interview process.  Most people who have opinions about the interview process in particular have it from only one side.  The one of being the guy looking for a job.  And, most of you only interview when you need a job.

What makes me qualified is that, I help interview people looking for a job and I interview for lots of jobs.  In my opinion, you should be interviewing for a job, even if you don’t need one, at least twice a year.  I interview more frequently than that.  In the last 6 months, I think I’ve interviewed at least 4 times.

So, let me start by telling you what the current interview process looks like, and why it doesn’t work.  Then, I’ll move on to the few interviews that I believe captured the information everyone was looking for quickly and how you can move the conversation in this direction regardless of what side of the table you are sitting on.

Revisiting The Technical Interview
Photo credit: Gangplank HQ via Visualhunt / CC BY

Continue reading “Revisiting The Technical Interview”

Angular 2 Thoughts

I was asked this past week what my thoughts were on Angular 2.  I wrote early on about my impressions of Angular 2 when it was barely done enough to review.  But now that I’ve been working with it for a while and know a bit more, what I want to discuss is more along the line of what it means to the average developer and, more importantly, organizations that are planning to use it.


Continue reading “Angular 2 Thoughts”

4 Reasons to Write Loosely Coupled Code

This past week I got into a small discussion about the importance of loosely coupled code.  Specifically, I was looking at event handler code that did nothing more than change the size of another element on the screen.  But the event handler code was in the controller which in the particular implementation we are using was the event handler portion of our Model in a MVVM architecture.  The question becomes does this code belong in the view, or does it belong in the controller?

The question of where code belongs leads eventually to arguments for loosely coupled code.  If I put code in my controller that is manipulating the view, then I either need to mock out my view in order to test my controller or I have to have an instance of my view available to test my controller.  Having coded enough systems to know that both of those choices are problematic, I opt for placing the view specific code in the view.  Another place where you might place this code would be in a View Specific event handler class.  But that would only be for the purposes of clean separation.  Something we might consider doing if the View were plain HTML.  But in our particular case, the view is generated from code, so placing the handlers in that same code seems to be the most appropriate location for it.

But all of this leads to a larger question.  Why should your code be loosely coupled at all?

4 Reasons to Write Loosely Coupled Code
Photo credit: Hernan Piñera via / CC BY-SA

Continue reading “4 Reasons to Write Loosely Coupled Code”

8 Reasons Johnny Does Not Write Bug Free Code

There have been a number of things that have occurred over the last week that have prompted this particular post.  And for anyone I work with, this is not an indictment of our work place so much as it is an indictment of our industry.  PLEASE don’t take this personally.

Some of those reasons will show up in this article.  But the question we need to examine today is why is it so hard to write bug free code.  And I’m not even talking about perfection.  Why is it that we miss the simple stuff?  The stuff that once it is found, we think, “how could we have missed that?!”.  I’m perfectly aware that all code has bugs some just haven’t been found yet.  I’m also aware that no matter how hard I try, the stupid bugs always make their way past my desk.

8 Reasons Johnny Does Not Write Bug Free Code
Photo credit: ~Pawsitive~Candie_N via Visualhunt / CC BY

Continue reading “8 Reasons Johnny Does Not Write Bug Free Code”