Although there has not been very much information given to the general public about upcoming features, the very recent patent applications from Apple have provided a strong hint of what the future will hold for your mobile phone. You better believe that these upcoming features are thrilling, and will change the way you look at and use mobile technology. In this post, we consider some future improvements, and what they can do for you.

The most appealing feature for future iPhones has to be the haptic tactile feedback that Apple is hoping to embrace. This is an attempt to simulate the physical keyboard / input panel and is expected to be an essential feature. This will allow the user to be able to sense the input panel on the touchscreen while typing or entering information. This will purge the need to for you to look at the screen all the time while typing, and allow you to take care of other business or even use applications while your phone is in your pocket. The haptic technology makes use of a piezoelectric actuators grid. Piezoelectric materials have the incredible property to be able to generate electricity when pressure is applied across them. In this manner, the touch based input components will provide a tactile feedback in the form of vibrations upon the application via pressure from the fingers during typing or scrolling. Thus, you would actually be able to feel the essence of real buttons even if you are actually working with virtual ones. All in all, haptic technology will enable mobile phone users to realize virtual reality through the sense of touch, which otherwise could only be realized through vision. This sort of interaction through virtual keys is implausible and has never seen before, nor even mentioned.

You have probably already seen a fingerprint sensor for security purposes when it comes to your most expensive gadgets. However, Apple has out thought everyone by expanding the use of fingerprint technology far beyond the more orthodox security purposes. This implies that you could now control your gadgets with your fingerprints only. The technicalities involved behind the screen would be as follows. Input sensing mechanisms are used to input the fingerprint signature through sensors and then a command is processed to be associated with that unique fingerprint signature. Accordingly, a database is created to store those signatures and the corresponding command is then associated with those signatures. This database can be modified at a number of different times. Now, when a user fingerprint is detected it is first matched with the samples in the database. If it matches with any of the prototypes in the database then the command associated with that prototype is executed.

To illustrate further, consider you have stored your index fingerprint in the database and associated a command to play the media player. On similar lines your ring finger print is stored with the command to play the media player. Now, if a song is being played on your iPhone and you place your index finger on the detector, the song will pause. To resume play you would simply place your ring finger on the detector. Hence, future iPhones are really going to out think and outmaneuver the current expectations of the electronic market.

Another expected feature in upcoming iPhones is the Radio Frequency Identification (RIFD) reader. There will also be tags which will be intended for providing several business applications to iPhone users (such as tracking library books etc.). Apple has been able to incorporate the RIFD circuitry into the touch sensor panel (it now also acts like a RIFD transponder) which has eradicated the requirement of extra space for the antenna. This has enabled Apple to integrate the iPhone with RIFD technology.

With such advancements, who knows what’s next! So, sit back, relax and get excited about the future iPhone. Maybe one day your iPhone will be able to do your laundry or wash your car. Hey, everyone can dream right?

We have the following broad categories:

Hardware
Software
Gadgets and Electronics
Product Reviews
YouTube Videos

We will add more as the forum takes off. But, for now, jump in and ask questions or share your knowledge

Design Goals

Starting out we are going to keep this pretty simple and as it progresses we’ll add more features.

For now we are going to start with a hand coded HTML table and CSS. In a later post we’ll look at populating the grid from a data source.

In this post today we’ll apply the CSS to the table but will expand this to a skinning system later on.

We’ll also be applying the row selection feature today.

Starting Point

Let’s use a simple table as out starting point.

<table cellpadding="0" cellspacing="0" class="easygrid">
    <tr>
        <th>Name</th>
        <th>Title</th>
        <th>Age</th>
    </tr>
    <tr>
        <td>Bill</td>
        <td>CEO</td>
        <td>53</td>
    </tr>
    <tr>
        <td>Jason</td>
        <td>Developer</td>
        <td>29</td>
    </tr>
    <tr>
        <td>Sue</td>
        <td>Accountant</td>
        <td>37</td>
    </tr>
    <tr>
        <td>Frank</td>
        <td>HR Manager</td>
        <td>42</td>
    </tr>
    <tr>
        <td>Jill</td>
        <td>Graphic Artist</td>
        <td>31</td>
    </tr>
</table>

Basic Style

Next we will apply some basic CSS to make our grid look nice.

body, table {
     font-family: verdana, arial, sans-serif;
}

table.easygrid {
     font-size: 11px;
     width: 600px;
     border-top: 1px solid #b8b8b8;
     border-left: 1px solid #b8b8b8;
}

table.easygrid th {
     text-align: left;
     padding: 5px;
     background: #424242;
     color: white;
     border-bottom: 1px solid #b8b8b8;
     border-right: 1px solid #b8b8b8;
}

table.easygrid td {
     padding: 5px;
     border-bottom: 1px solid #b8b8b8;
     border-right: 1px solid #b8b8b8;
}

table.easygrid td.alt {
     background: #f6f3f6;
}

table.easygrid td.selected {
     background: navy;
     color: white;
     font-weight: bold;
}

Building The Plugin

Here is the basic layout of our plugin. We’ll look at implementing those functions in a minute.

This is pretty simple so far. We have our default values, we merge the user passed options with the defaults, and then call two methods on each jQuery instance.

(function($) {
     $.fn.easygrid = function(options) {
         var defaults = {
             alternateBackground: true,
             allowRowSelect: true
         };

         options = $.extend(defaults, options);

         return this.each(function(index, table) {
             setAlternateBackground($('tr:odd td', table), options.alternateBackground);
             rowSelection(table, options.allowRowSelect, options.alternateBackground);
         });
     };
})(jQuery)

Here is our setAlternateBackground method. Note we are passing all the odd rows found in the current table.

function setAlternateBackground(rows, alt) {
     if(alt == true) {
         rows.attr('class', this.className + ' alt');
     }
}

This function appends the alt CSS class to each row if alternate row backgrounds is enabled.

The next function adds a click handler to each row to implement the row selection functionality.

function rowSelection(table, allowSelect, alt) {
     if(allowSelect == true) {
         $('tr', table).click(function() {
            //reset all rows
            $('tr', table).each(function() {
                $('td', this).each(function(index, cell) {
                    $(cell).attr('class', cell.className.replace(' selected'));
                });
            });

            //restore alt backgrounds
            setAlternateBackground($('tr:odd td', table), alt);

            //select this row
            $('td', this).attr('class', this.className + ' selected');
        });
    }
}

There is a little more involved with this function. If this feature is enabled we are adding a click handler to all the rows in the table.

First the click handler will clear any selected rows and reapply the alternate background colors. I am not sure why this gets lost.

Then, finally, the row that was clicked is selected by applying the selected CSS class to each cell of the row.

What’s Next?

That is it for this post but we will look at adding sorting to our grid in post in the near future.

Currently the row selection is a bit buggy in Firefox but works fine in IE. I will have the Firefox issues sorted out for the next post. You can check out a demo here.

Be sure you don’t miss out by grabbing the RSS feed, updates by email, or following on Twitter.

The visitor design pattern is a way of separating an algorithm from an object structure upon which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those structures. Thus, using the visitor pattern helps conformance with the open/closed principle [Wikipedia].

Our Requirements

One principle that I really like is the Open/Closed principle which says that an object should be open to new functionality but closed to structural changes. The visitor pattern helps facilitate this principle by giving us the means to perform operations against an object without changing the objects structure.

Looking back at a previous pattern we wanted to adjust the registration cost for a dog if they had been picked up by the dog catcher.

Implementing The Visitor

Supposing we have the implementation for the interface below we could use the visitor pattern to perform our tasks without changing the existing classes. Since we won’t be changing the existing implementation we don’t need to worry about breaking existing features. Lets assume that the repository returns 3 infractions for our dog in the code below.

internal interface IDog {
    int Id { get; set; }
    string Name { get; set; }
    string Breed { get; set; }
    string Address { get; set; }
    DateTime RegisterDate { get; set; }
    int RegistrationCost { get; set; }
    ICollection<Infraction> Infractions { get; }
    void Accept(IVisitor visitor);
}

So we have our dog class and we have our visitor setup. All we have left to do is execute it.

Conclusion

So just like the Decorator pattern, with the visitor pattern we can modify our class without changing the classes code. This pattern is more flexible because we can create any number of visitor classes to do just about anything without changing any code.

Be sure to grab the RSS feed, sign up for email updates, or follow me on Twitter to stay up to date and not miss any posts.

The C# Design Patterns Series

Part 1 - An Overview
Part 2 - The Decorator Pattern
Part 3 - The Abstract Factory Pattern
Part 4 - The Observer Pattern
Part 5 - The Facade Pattern
Part 6 - The Visitor Pattern

There has always been and probably always will be feuds over what is the best platform but what I want to show you is that those arguments are mostly irrelevant. Regardless of what platform you choose to develop on there are most of the same tools available in one form or another. The common components, for me anyway, that help me produce high quality code faster and is easier to maintain are a good IDE, easy to use unit testing and mocking frameworks, an ORM, a MVC framework, and a good JavaScript library.

I am a .Net developer by trade and a PHP developer sometimes by choice. I enjoy both environments for different reasons. I am going to talk about each of these components in a bit of detail and explain why I think they are important and then at the end of the article I will provide a list of each of these components for various languages (.Net, Java, PHP, Python, and Ruby). I have decided to only list free or open source tools because they are easy for someone to try out and we all like to save a few bucks.

The Integrated Development Environment (IDE)

To me this is the prime essential. Sure you can program in Notepad and compile with the command line but it will likely take longer and it will require more discipline to stay organized. With a good IDE you have easy project management (all you files grouped together with tabbed browsing), syntax highlighting, compilation (if applicable), and auto complete.

IDE are continuously getting more and more sophisticated and plugins allow for lots more functionality like svn and git management in the IDE.

For me my favorite IDE is Visual Studio. There are some other great programs out there like NetBeans and Eclipse but for whatever reason I have become partial to Visual Studio.

Unit Testing And Mocking

These two items go hand in hand. No application is complete without proper testing. There are plenty of people on both sides of the fence when it comes to testing. I know, I was a skeptic for a along time. It just felt weird to spend time writing code to test the real code I was going to write. Finally I just decided to give it a try and it has changed the way I program. When you are focusing on how to test your code you just write cleaner code and it’s nice to have a quick way to know if the change you just made broke anything.

Object Relational Mapper

If you have ever used an ORM you know that it can save you a huge amount of time. One of the concerns I had before jumping to an ORM was performance. I wanted to know if using an ORM would make my application slower but I was asking the wrong question. I should have been asking whether or not the small performance hit was worth the huge time savings. The answer to that is a definite YES! Rarely in an application will the ORM be the source of poor performance and if it is it can be refactored to improve or you can use straight SQL if need be.

It all comes down to not worrying about performance issues before you have any. Yes it is important to keep performance in mind but using an ORM shouldn’t be anything to worry about.

MVC Framework

MVC has become very popular thanks in part to Rails and it’s revolution in the way we do Web Development. The key component to it’s popularity is that it separates the different concerns of your application into seperate pieces. This separation allows easier testing, better design, and makes your application more maintainable overall.

JavaScript Library

It seems there is a JavaScript library for just about everything these days. I remember not too long ago there were that many and JavaScript use hadn’t exploded yet. A JavaScript library is important to your productivity. The library shouldn’t compensate for poor JavaScript skills, you need a solid foundation, but should compliment a good understanding of it. The library will take care of browser compatibility issues and low level operations letting you focus on getting the job done.

ASP.Net
IDE: Visual Studio 2008 Express
Unit Testing: NUnit
Mocking: Rhino Mocks
ORM: NHibernate
MVC: ASP.NET MVC
JavaScript: jQuery

Java
IDE: NetBeans
Unit Testing: JUnit
Mocking: EasyMock
ORM: Hibernate
MVC: Struts
JavaScript: jQuery

PHP
IDE: PHPEclipse
Unit Testing: PHPUnit
Mocking: PHPMock
ORM: Propel
MVC: Symfony
JavaScript: jQuery

Python
IDE: PyDev
Unit Testing: PyUnit
Mocking: PythonMock
ORM: SQLObject
MVC: Django
JavaScript: jQuery

Ruby
IDE: RadRails
Unit Testing: Test::Unit
Mocking: Mocha
ORM: Sequel
MVC: Rails
JavaScript: jQuery

Be sure to grab the RSS feed, get updates by email, or follow me on Twitter to stay up to date and not miss any posts.

What Is The Facade Pattern

The facade pattern is a higher level interface that simplifies and brings together multiple interfaces of a subsystem. What this means is if you want to do something but that requires interacting with multiple subsystems you can create a facade that same only a few methods that handle all the interaction with the subsystem.

Our Application Requirements

In our city dog registration application lets assume there are a few things that need to be done when a new dog is registered. First the new dog and it’s owners must be entered into the system. Next the registration fee must be processed. Finally, we want the system to send the owners the welcome email.

This is a very simple example but this action requires 3 separate systems to do something in order to complete this one task of registering a new dog.

Using The Facade Pattern

For the sake of simplicity and not cluttering this post with too much code, I am not going to provide code for the sub systems, just the facade.

public class RegistrationManager : IRegister {
    private IAccountingService _accounting;
    private IMessageService _messaging;
    private IRepository = _repository;

    public RegistrationManager(IAccountService accounting, IMessagingService messaging, IRepository repository) {
        _accounting = accounting;
        _messaging = messaging;
        _repository = repository;
    }

    public void RegisterDog(IDog dog) {
        _repository.AddDog(dog);
        _accounting.ProcessPayment(dog.PaymentOrder);
        _messaging.SendWelcome(dog.Owners.Find(x => x.PrimaryContact))
    }
}

As you can see this is a very simple example but it illustrates the concept of the pattern. We have taken 3 tasks, each belonging to a different sub system, and combined them into 1 task in a facade class, in this case the RegistrationManager class.

The RegisterDog method adds the new dog to the repository, sends the payment order to the accounting system, and sends a welcome message to the dogs owners that are flagged as primary contacts.

Summing It Up

I hope this post helps you understand the Facade pattern and I hope you are continuing to learn and have fun with this series.

Be sure to grab the RSS feed or follow me on Twitter to stay up to date and not miss any posts.

The C# Design Patterns Series

Part 1 - An Overview
Part 2 - The Decorator Pattern
Part 3 - The Abstract Factory Pattern
Part 4 - The Observer Pattern
Part 5 - The Facade Pattern

I’m not going to rehash everything but I will sum up the two sides and throw my opinion into the ring. Why does my opinion matter? I’m not so sure that it does but you can be the judge of that. What I do think is different about my opinion than the opinions that I have heard/read so far is that I can’t place myself in either camp. I am not a coding cowboy that just cares that “it works” and I am not a bureaucratic standards Nazi either. I’ll talk a bit more about why I am ducking for cover in no man’s land in this battle of opinions.

The Coding Cowboys Say

Jeff Atwood and Joel Spolsky sure hit a sore spot when they suggested that learning programming principles just wasn’t worth it and just getting it done was more important.

Jeff likened principles and guidelines to the Ferengi and their 285 Rules of Acquisition saying that every situation in programming cannot be governed by a set of rules and there isn’t a one size fits all pattern to solve everything.

Joel refers to the SOLID principles as “extremely bureaucratic programming that came from the mind of somebody that has not written a lot of code.”

The Craftsmen Say

Jeff and Joel’s comments sparked a lot of rebuttals from the ALT.Net community. It is understandable since those comments attack the very foundation of TDD and DDD. I am not going to bore you with a list of everyone that chimed in but I want to highlight a post that I think sums up this position in a clear and nice way.

Justin Etheredge made a great post is response to the criticisms. I have been reading Justin’s blog for a while and I like the way he views software. He likens software development to carpentry and woodworking, both are a learned craft. You don’t get good a carpentry by throwing things together and ignoring building codes. Patterns and principles are like building codes.

My View On The Whole Thing

I was a bit surprised at first to hear Jeff and Joel’s comments because they are some smart guys that have produced some successful software. I highly doubt, regardless of how it came across, they intended to imply that you should ignore all guidelines and just string together your code. Unfortunately, the comments of their posts make it all too clear that this is exactly the way a lot of programmers took it. What’s worse is bad programmers will use this as a defense for their resistance to improving their skills.

Like I said, currently I am somewhere in no man’s land. For too long I had the mindset that would take Jeff and Joel’s comments and use them as an excuse to ignore patterns and principles. From the beginning of my education in software development, no importance was placed on “good design.” My college training only focuses on teaching the syntax and considering that “knowing” the language.

After a few years of living in denial, I had to accept that their was far more for me to learn and I began my journey out of the cowboy coding camp and started striving to develop software in a TDD manner. I still have a lot to learn but facts cannot be ignored. Since making an effort to improve my craft I have seen a significant drop in the amount of bugs found in new software I am producing and the bugs that are found are smaller and much similar to solve. So that is my take on the whole thing and I hope that this at least peaks someone’s interest to dig a little deeper in regard to becoming a craftsmen and taking pride in the code they produce.

With the idea of job security pretty much non-existant, what can you do to help insulate yourself from these tough economic times?

Now is a perfect time to work for yourself as a freelance consultant. Yes it is! Here is why.

3 Reasons You Should Consider Becoming A Freelance Consultant

1. Even though companies are laying people off, the jobs still need to get done. Big companies may outsource to other countries but small to medium businesses will likely look to local consultants to fill the gaps they can’t afford to fill with full-time employees.

2. Your costs are relatively low. The costs to strike out on your own are pretty low. You can arm yourself with free and open source software to fill almost all your operational needs. I will do a post later on starting up a business using open source and free software. Health care will likely be your biggest expense.

3. Your time is your own. Imagine walking to the hardware store, eating lunch with your significant other, or playing soccer with your kids in the middle of the day! Well, as a freelancer you can do that. You set your work hours and you decide how much you need/want to work.

If you have been recently laid off or are frustrated with or feel trapped in your current job maybe making the jump to being a freelance consultant is something you should consider.

This is an area that I’ll expand on in future posts so make sure you grab the RSS feed or follow me on Twitter.

The Proposal

Occasionally I am going to review a book or service that is relevant to programming, running a website, running your own business, or technology in general. You can take a look at the list of products I will be choosing from here. There will also be a few hanging around on the right side bar as well.

How To Get It Free

The best part of these reviews is that you will easily be able to get these books and services for free. That’s right. These will not be paid reviews so they are my honest opinions. I will have personally used these products so I won’t promote anything that is crap and that I wouldn’t use myself.

In the interest of full disclosure, I do get paid for qualified leads. Meaning, if you decide you want to give the service or book a try, you fill out a small form before you receive the product. If you qualify, I get paid a couple bucks.

I hope that you will find these reviews useful.

In this post we are going to take a look at the Observer pattern.

What Is The Observer Pattern?

The Observer pattern is a way for an object to notify all of it’s dependants when something changes based on a one to many relationship.

The Situation

Continuing to use our city dog registration software senario, one of the project’s requirements is that the dog’s owner’s be notified whenever a dog is processed for an infraction (i.e. picked up by the dog catcher). The Observer pattern is perfectly suited to solve this problem.

Setting Up Our Observer

First before we create our Observer we need to define some classes and interfaces that we will need to use with the Observer.

}

The above code defines an infraction and an owner for our Observer to use. Now we can setup our Observer and the notifications when a dog gets an infraction.

You can see the this pattern at work in the AddInfraction method. Everytime this method is called an infraction is added to the dog’s record and all the owners are sent an email detailing the infraction and where to pick up their dog. It’s nice when you can structure your code to handle situations automatically, for you and your clients.

If you enjoyed this post be sure to grab the RSS feed or follow me on Twitter to get notifications of new posts. Also, check out other posts in this series below.

The C# Design Patterns Series

Part 1 - An Overview
Part 2 - The Decorator Pattern
Part 3 - The Abstract Factory Pattern
Part 4 - The Observer Pattern