An Open Letter To My Future Employer
Hello Future Employer of Mine,
I want to speak to you honestly and frankly. I need to tell you
about myself in greater detail than a resume could. I need you to know
up front what kind of organization I can be my best in. I hope you do
not take me to be conceited for writing this. Rather that I know what I
need out of life, and that I am attempting to share my experience and
reasoning with you in order to achieve it.
To put it bluntly, I’m 30 years old and have spent the past three to four years looking for a company I could excel in. I have come to the conclusion that the company I work for and I must think along the same lines. I’m getting old(er)! I really don’t have time to waste being unhappy in a job that I should love! I’d write software for free if I could still eat at the same time. I want to wake up each morning happy, excited even, to come to work. I want you to be happy to pay me a couple times a month, with both of us feeling like we got the good end of the deal.
Fortunately, I have had this experience before.
You can look
at my resume and see
Mirim LLC. Mirim was my favorite job by far. We
did things
generally the way I am about to express to you in this letter, and we
produced
some awesome software, on schedule, at cost if not below, and had some
fun in
the meanwhile.
Unfortunately, since then I have been looking for
another
great team of people to work with. In that time, I have come across
some terrific people, people with the desire to do great things, but it
has been my
experience that the organization and what it said was the way things
must be
done has hampered them. These ways invariably led to problems,
frustration,
and lower
morale on the team.
I believe that a software team should operate efficiently, as
efficiently as
possible. An efficient team is one that places great importance on
doing things
the best way possible. I would not be happy in a job where things are
done a
certain way just because that’s the way things have always been done.
There
needs to be an atmosphere where anybody can bring up any issue they
have and
have it addressed by the team in a timely manner. The addressing of
that issue
may be to decide its not actually an issue, or at least not worthy of a
change in process. It may be that we just cannot, or will not, do it at
this time, and it will be revisited later if necessary. In whatever way
it is finally decided upon, it should be seriously considered
by the
team.
I believe that if it can be demonstrated that
a process is
not efficient, it needs to change. I choose to be a developer for the
experience of
creating
great software. You as my employer are in business to sell great
software,
or
to otherwise make use of great software in your organization to make
your
sales of
something else higher. We both want money out of this deal. We are in
this as a
team. If our team is not efficient, that means we are losing money, and
that
doesn't do anybody any good. If our process is not efficient, then what
are we
really doing? Now without taking too much more time on this, I
understand that
there are going to be differences in opinion as far as what is
efficient. I am not always correct; I can take rejection. Open
communication from all of my team members is all I really need.
Communication is the key. If
we can talk about the issue, we can come
to an
accurate understanding of it, and we can then determine an accurate and
efficient solution.
I believe there is a way that you develop software. There are things you simply must do, or else you are doing it wrong. These things form a general description of how things should be done, that can be applied to any organization. When these methods are applied to an organization, it invariably leads to higher quality software, developed faster, developed cheaper, and with happier developers.
I am an object-oriented developer. That means that when I think of a problem, I think of it in objects. I think of it in the smallest pieces I can. Then I think about how I can put those small pieces together most efficiently in order to achieve a solution. When I code I think of the task at hand, designing a solution in my mind, determining how it can be accomplished with Object Oriented Principles. I try to make the most of Inheritance, Encapsulation, and Polymorphism. I need to work in a company that recognizes that the language is not the important part. Over many years, I have written code in Applesoft Basic, QBasic, Visual Basic, ACOS, 65C02 Assembly, RPG, C, C++, Java, and C#. After a while, it’s not the language that is important, it is the process in which you think. The language is simply a means to an end. Some languages are better than others depending on the end you are trying to get to. Also, the fact that you have not yet learned a language does not mean you are any less capable of using it to achieve the desired outcome. There is always going to be a newer, better, greater, more fantastical language coming up. I need an environment that looks at the thinking process used more so than the syntax used.
My thinking process is especially important to me when I am writing something from scratch. By keeping appropriate design tenets in mind when writing code, I find you produce code that will make your job easier later. It will be easier because it will be easier to understand, and easier to adapt to other purposes. If one designs their objects with the philosophy that an object (and in turn, the methods in the object) should do one thing, and only one thing very well, those objects can be used in many other situations, most that are probably inconceivable at the time the object is written. It is similar to a phone jack in the wall. When phone jacks were first invented, the only purpose was that a phone would plug into them. But today, you can have a fax machine, a modem, your Tivo, and hundreds of other devices that plug into that single object that does one thing very well.
Now that you’ve read a little about me, there are some concrete things I believe a team needs to have in order to be efficient, after, of course, computers. The team should make use of software specifically designed for
- Design
- Development
- Defect and enhancement tracking.
- Source code control (i.e., a source repository like SourceSafe, Dimensions or CVS)
- Testing
- Code documentation
- Team collaboration
- Product Management should schedule firm release dates.
The scheduled release dates should be set in wet cement. By this I
mean that they should be considered concrete, and having to move them
should be a rare occurrence. If they are moved, they can only be moved
a relatively short distance.
Using milestones, or mini-release dates, can help to keep scheduled dates. By checking that feature X has been completed by a certain date, and that certain functionality has been coded by another date, etc, the team can gauge progress over the time leading up to the final release date and make adjustments where necessary.
- Product Management should determine the features of each
release before the development on that release begins. Adding
features after a release has begun development should be
extremely rare. Rather than changing the current schedule, those items
that come up later should be added to the next scheduled release,
unless it absolutely must be released now. Because business
happens,
right? But if it is a dire need that absolutely must be released now
and we did not
schedule it before the current release began development, that
indicates a problem in our process, and we need to find out what
happened and why and how we can address it, because this unanticipated
major feature simply should not have surprised us.
If it is determined during the development of a release that it simply will not be possible to code a feature by the release date, features should be removed and put on the next release schedule.
- Product Management should have firm, complete, written requirements for features to be
developed. Without requirements, it
is not possible to gauge how long something will take to develop, or
when it is
actually done. Change will always happen, things will be overlooked,
but major additions to requirements should only be allowed if
there is time in the schedule. Then as before, the process should be
reexamined to determine why this change was initially overlooked and
how we can do it better next time.
- Development should build the code in its entirety on a daily basis. This process should be automated, meaning the computer should do it all for us. But for this to happen, a developer must be able to build their code from the command line in two simple steps, Pull and Build. Pull the code from the source code repository to the local machine and then type a single command, or push a single button to build the software. There should be only two steps, no intermediary path fixing or button pushing, only two steps. This allows the team to:
- Focus on developing code rather than how to build the software.
- Deliver a build of our codebase as it stands on any day, just as soon as it is requested. This is especially useful in determining if scheduled functionality is actually complete or behind schedule.
- Flesh out build errors faster because no more than a working day will have gone by without someone noticing the build is broken.
- Get donuts from the perpetrator on the day
after
someone breaks the build.
- The team should consider each build a
different version of the
software. The build that we did today is different from the build
we did
yesterday, even if nothing changed in the code. For example if we are
working
on version 1.0 of the code, our first build would be version 1.0.0.1 or
version
1.0 Build 1, or something to that effect. The build we do tomorrow will
be
version 1.0.0.2 or version 1.0 Build 2. Each day’s build is a different
version.
- Development should mark the code in the source repositorty
each time a build is done. In SourceSafe, for instance, this is
called
labeling the code. This will allow the team to build any version of the
code at
any time. For example if Quality Assurace (QA) tells us that there is a
major bug in
version X
that is keeping them from doing further testing, but we’re sure it
wasn’t in version
X-1, it
is easy to Pull and Build version X-1 to get them back on their way
while we
address the major bug.
- Quality Assurance (QA) should test all of the code at
one
time, at
regular intervals. During the testing phase of development, QA
should be
given a complete copy of the code, that is, whatever is necessary to
install it
on a clean machine and run through everything the software does,
testing every
bit of functionality, from little things like the text in a dialog to
major
functionality. When bugs are found, they should be written up in a
detailed
manner, and put in the bug tracking software. QA should continue to
test this
version until they have tested each aspect.
Product Management should then review each bug and determine a priority. This tells Development (Dev) where to apply their efforts.
When Dev fixes a bug, it should mark the bug fixed as of version 1.0 Build 45 or whatever the case may be. When the interval comes up to give QA a new build, QA is given the build for that day. They should repeat their cycle, testing every aspect of the system, paying specific attention to bugs previously found, to see if they are fixed. If they are fixed, they close the bug out.
Eventually, all the major bugs will be fixed and closed. PM can then determine which existing bugs they can live with in an official release.
Though not an exhaustive list, these are things that I consider very necessary in order for a team to be its most successful. Of course, there are going to be exceptions to some of these things, different things will apply to some organizations that won’t to others, and there will be other systems that can do just what I’ve described above. I don’t think it is critical that my ideas are the only ones that are followed, just that these things are important and I honestly need them or something like them in place to be my best.
As a final
belief, I believe
it is okay that you don’t do things this way. I believe it is okay for
you to
have whatever system you want. I only present these things as a list of
attributes I will
be looking for in an organization, or at least a willingness to address
these
concerns in some way. An organization with that willingness, meaning it
was willing to look
at its
process and update it where necessary, not for my sake, but in order to
do the best possible
job, is what
I am looking for. I am writing this letter to that organization. I want
that
organization to be my future employer.
Of course my contact information is all over this website. If you
got this far, I hope you want to read my resume (word format here) too. If
you represent the organization I have in mind, and have a need for
someone like me on your team, I'd be ecstatic to hear from you.
Thanks for reading all of this!
Johnathan James
The Reader's Digest version of this letter is here.
