The Internet is awesome. It has made the world more like a small town. However, part of being a small town is that news travels fast – and companies seemingly haven’t caught on to that yet.

Blogs, Twitter/Facebook/Social media, and Internet news sites have information moments after a company makes a decision (often before it is announced, due to information leaks).  Once the news is out the opinions start rolling in, and since the Internet gave us all a voice, we should use it to complain. We no longer live in a world where a business can silently screw us over with their decisions.

Recently, some companies have been reversing unpopular decisions due to Internet backlash (examples: Netflix/Qwikster split and the very recent $2 “convenience” charge for online bill pay from Verizon) which is a good thing. Since we now have a central forum to voice our complaints I hope another travesty like cable television will never arise.

Direct lines of communication will not work. You may think that a call to the corporate office will help; or an email to customer service will get your message across. Do you know what these are? Private “conversations” that can (and will) be ignored – it is just one voice. Now if you took your complaints to Twitter, for example, you join the massive list of complaints that are surely already there. There is safety, and power in numbers.

Eventually people will realize that a company will either listen to the customers, or ignore them. If it is the former then the company wants your business and deserves your support; if it is latter, however, then kick them to the curb.

Don’t sit back and take it; don’t assume you’re the only one. Go and voice your opinion. You can help bring a change.

Python (source: http://xkcd.com/353/)

class Person:
    # Constructor
    def __init__(self, n, a):
        # Private Variables
        self.__name = n
        self.__age = a

    # One way to do properties
    @property
    def name(self): return self.__name
    @name.setter
    def name(self, value): self.__name = value
    @name.deleter
    def name(self): del self.__name

    # Another way to do properties
    def __get__age(self): return self.__age
    def __set__age(self, value): self.__age = value
    def __del__age(self): del self.__age
    age = property(__get__age, __set__age, __del__age, "Age of the person")

    def ToString(self):
        # Print Person Information
        print("Name: %s" % self.name)
        print("Age: %d" % self.age)

from Person import Person

# Employee inherits from Person
class Employee(Person):
    # Constructor
    def __init__(self, name, age, job):
        # Call Parent's constructor
        super(Employee, self).__init__(name, age)
        # Do my own setting
        self.__job = job

    def ToString(self):
        # Display Employee Information
        super().ToString()
        print("Workplace: %s" % self.__job)

    # Employee specific function
    def Work(self):
        print("Going to work.")

from Person import Person
from Employee import Employee

# If the program is run as a main program
if __name__ == '__main__':
    # Create a person
    p = Person("Harrold", 62)
    # Create an Employee
    e = Employee("Nancy", 21, "Burger Flipper")

    # Make an array of people
    parray = [p, e]

    # Iterate through them and display the results
    for m in parray:
        m.ToString()
        print("")

>>>
Name: Harrold
Age: 62

Name: Nancy
Age: 21
Workplace: Burger Flipper

Edit @ 2:39pm

Reading more, found the default “ToString” of Python is __str__, adjusted accordingly:

Person.py

class Person:
    # Constructor
    def __init__(self, n, a):
        # Private Variables
        self.__name = n
        self.__age = a

    @property
    def name(self): return self.__name
    @name.setter
    def name(self, value): self.__name = value
    @name.deleter
    def name(self): del self.__name

    @property
    def age(self): return self.__age
    @age.setter
    def age(self, value): self.__age = value
    @age.deleter
    def age(self): del self.__age

    def __str__(self):
        # Print Person Information
        return "Name: {0} {1}Age: {2}".format(self.name, "\n",self.age)

Employee.py

from Person import Person

# Employee inherits from Person
class Employee(Person):
    # Constructor
    def __init__(self, name, age, job):
        # Call Parent's constructor
        super(Employee, self).__init__(name, age)
        # Do my own setting
        self.__job = job

    @property
    def job(self): return self.__job
    @job.setter
    def job(self, value): self.__job = value
    @job.deleter
    def job(self): del self.__job

    def __str__(self):
        # Display Employee Information
        return "{0}{1}Workplace: {2}".format(Person.__str__(self), "\n", self.job)

PersonTester.py

from Person import *
from Employee import *

# If the program is run as a main program
if __name__ == '__main__':
    # Create a person
    p = Person("Harrold", 62)
    # Create an Employee
    e = Employee("Nancy", 21, "Burger Flipper")

    # Make an array of people
    parray = [p, e]

    # Iterate through them and display the results
    for m in parray:
        print(m)
        print("")

Behold! The pinnacle of devices! (Source: http://en.wikipedia.org/wiki/Gameboy)

My things used to last. I could throw them across the room and know they would break whatever they hit. Today I have neoprene cases, screen protectors, carrying cases, shock absorbing skins and microfiber clothes all to ensure that whatever I have doesn’t end up a smoldering mess before the day is out.

Sure, things might be smaller, faster, and more expensive nowadays. But what did we sacrifice? Ease of mind. I mean, would your iPhone survive a grenade blast? Doubtful.

Grenade to the face and STILL playing Tetris.

Not to mention that the original Game Boy had a lifespan of 9 years before being replaced by the Game Boy Color. You could still use NEW software on 9 year old hardware. I doubt we will see anything like this again.

Today it’s all about the quick turnaround and it is making my wallet weep. It’s like companies design their products to fall apart just in time for them to reveal the updated version; and if so, that is just shitty.

The updateoholic in me LOVES that technology is constantly updating and getting better. The cheap bastard in me hates that with the shorter life cycle of mobile devices, that prices have not plummeted. And the sentimental nostalgic in me wishes for a simpler time, where I can squint at my tiny green screen.

What does that mean? It means I spend more time pouring over articles and newsletters looking for glimpses of soon-to-come features of software, than I do using the new features.

It means that I perform the “Check for Updates” check on every device I own, in every piece of software I own, on a daily basis.

It means I have a problem. Or do I?

Updates are a good thing, they can add new features, fix old problems, or introduce new concepts. Most importantly, however, updates mean that the project being updated is not dead. The developers haven’t forsaken and forgotten their software. It means that whatever I have invested into the project (time, money, loyalty, whatever) hasn’t been a waste.

Be good to your customers, update often.