pushing the envelope

I’m a cash person. I deal in cash and I don’t consume credit. I don’t have a checking account, savings account, no IRA and no ATM or credit cards which are bound to a checking account. From time to time I purchase a pre-paid Visa card so that I might make online purchases, but I prefer in-person cash payments over any other.

When I want something in the future, I put the money into an envelope, seal it and mark it with its purpose. I don’t allow myself to open that envelope to re-purpose those funds to something else I want or need. I exercise person fiscal responsibility.

I try to refrain from recurring payments if possible. Notable exceptions are my rent and my Internet bill.

Remembering the Past

At one time, I had a wallet full of credit cards. I recall that one of them alone had a credit limit of over $115,000 on it. That’s a lot of room to get into trouble if you think about it. I do remember making payments to those credit card companies. I can’t even remember how much combined interest I paid since we’re not really conditioned to think of such things—we only remember the things we bought at the time. And this is how we’re programmed to think within the credit-buying space:  focus on the reward and forget about the cost.

“And this is how we’re programmed to think within the credit-buying space:  focus on the reward and forget about the cost.”

Planning For the Future

I am proud to say that I have the next eight months rent in their respective envelopes. I think the average person in the U.S. is living paycheck to paycheck. In fact, it looks like 76% of Americans are living paycheck to paycheck (according to a bankrate.com survey) so I guess that makes me special.

“…76% of Americans are living paycheck to paycheck…”

Minimize Consumption and Buy Locally

As a personal goal I try to minimize consumption, that is to say the purchasing of retail goods within the description of “shopping therapy”. When I do, I try to buy locally. If I can accomplish this, I’m moving more of my economical support to the same place where I live and that helps my local community instead of someone else’s.

Just think of the drop in the U.S.’s dependency on oil imports if we could cut our transportation costs by 80% across the board. And yet everyday the highways have a constant stream of trucks bringing goods and food interstate. We’re conditioned to believe that cost alone is the most critical factor in deciding from which vendor we purchase those goods. Maybe we should change our thinking to select instead the best vendors who are the closest to us. The fewer the miles, the less the transportation cost ultimately. This should go beyond which store we buy from but also from where that store gets its goods. Do all of our manufactured goods need to come from China? Well, they do if you’re shopping by price alone.

Re-use, Recycle, Maintain

I buy used cars and you should, too. The average person panics when their car’s odometer reaches the 100K mark but don’t fear a number, the car will continue to drive even at the six-digit mark, trust me. It does help to understand some basic car maintenance. Change your own spark plugs, the job isn’t that difficult.

I spend an extra $2 for the really good milk in glass bottles (some sort of pre-paid deposit). And then I use that bottle to store dry goods purchased in bulk at the grocery store. The average quart-sized glass storage container might cost from $5 to $30, by the way. As an added benefit the bugs that formerly lived in my cupboard have given up completely and moved on.

Learn how to fix things. Sew. Solder. Sand and refinish. I recently converted a pile of recycled PCs into a private cloud. The skills you learn now you get to keep for life.

Recognize That the Economy and the Market are Fickle

You can’t predict the future, you can only plan for it. I’m old enough to have survived lay-offs, company buy-outs, company closures and the like. I lost my largest customer one day to outsourcing and it took me quite some time to rebound because I wasn’t prepared for such an eventuality. The entire software development industry almost overnight changed and I didn’t see it coming. Although I was making great amounts of money I still wasn’t adequately setup to bounce back from such a sudden loss of income.

So now I think I’m a little more pessimistic about the market in general and I take pains to avoid repeating any past mistakes.

Push the Envelope

And finally, I come to the meaning behind this post’s title. Each paycheck I try to do what I can to seal yet another month’s rent into a new envelope, pushing my savings out into the future. It’s not a bad system. I’d suggest that you’ve been programmed to believe that you can’t exist without a checking account but I assure you, you can.

envelope

Advertisements

royalty-source code

The Concept

Here, I’m coining a new term for the software development world.  Similar to open source software, royalty-source code would be widely available for download via a system like github.  Unlike open source, however, royalty-source includes a mechanism so that each coder gets paid as programs get downloaded.  This new mechanism should fairly distribute royalties based upon some sort of weighted system for each of the dependencies.

Typical Dependencies

The following tree shows a typical collection of dependencies pulled into a new Node.js program named MyNodeProgram, as an example, with the single command npm install mongoose:

  • MyNodeProgram
    • mongoose
      • async
        • benchmark + 22 other dependent libraries
      • bson
        • nodeunit
        • one
        • benchmark
        • colors
      • hooks-fixed
        • expresso
        • should
        • underscore
      • kareem
        • acquit
        • gulp
        • gulp-mocha
        • gulp-jscs
        • istanbul
        • jscs
        • mocha
      • mongodb
        • etc
      • mpath
        • mocha
        • benchmark
      • mpromise
        • etc
      • mquery
        • etc
      • ms
        • etc
      • muri
        • etc
      • regexp-clone
        • etc
      • sliced
        • etc

Doing a directory listing of your program’s node-modules subdirectory should then reveal just how much code got pulled from github with that single npm install command earlier.

Royalty Debt

Unlike open source coding projects, royalty-source coding projects add a new concept to the business model.  Royalty debt is the added virtual cost to your project with each npm install command you invoke.

If you envisioned charging $1.00 for each download of your own program and it now contains that mongoose dependency from before, you’ve greatly diluted your own code with the inclusion of this large collection of code that somebody else created.  If you created a typical Hello World program that uses a MongoDB database and assuming that you only add a few lines of your own code, then you might only get $0.01 of that $1.00 download royalty and everybody else would get the remaining $0.99 of that sale.  Without that mongoose inclusion, it would be unlikely that anyone would want to pay you $0.01 for your code, at least in theory.  You might then accept this 1% ratio as what it takes to make money.

Instead, you might start to rethink your entire program from the ground up.  If you could remove the mongoose dependency and store your data in a simple BSON object instead you possibly could drop that dependency completely and the royalty debt it incurs.  Assuming that you no longer had any other dependencies and people are still happy to pay the $1.00 price tag, 100% of that is now yours to keep.

One big benefit to this concept of royalty debt is that it should incentivize coders to review that stack of dependencies to look for anything that’s been included and yet which doesn’t add much value to the overall project.  The coder then should remove any unwarranted code to lower the bloat effect we often see in open source projects.  Smaller code is often better code.

Pay the House

Obviously, whoever is the new github provider will charge a commission of some kind for each download.  The download price minus the commission equals the total royalty to be split up.

Hopefully this system would include balances which would allow someone with existing credits to then use them to download other code.

Royalty Distribution

Presumably, a value system would be in place which weighs each dependency against the parent program’s code with some kind of fair distribution model.  As in the above Node.js example, the benchmark code appears at least three times as a dependency and should then get a bigger piece of the pie, so to speak.

New Tools

Given that we’d now have royalty debt to think about before adding a new dependency to our project, we should have some tools to quantify that cost.  In theory, you’d run the npm install command with an extra argument which quantifies that module’s package.json dependency list.  Let’s say that you might run the following command from your MyNodeProgram folder:  npm install mongoose --cost

At this point, npm might indicate…

mongoose @4.3.5:  Cost=$0.99/$1.00

Note that this is assumed to be a guesstimate at this time since your own program’s few lines of code were compared to the collective code and dependent modules of mongoose to return this ratio.

As a coder, you now have a build-versus-buy decision:  1) build your own database code instead or 2) expect to pay for mongoose (and dependent code) with each sale/download of your own code.

Pay the Piper

Obviously, it wouldn’t be fair to the coders of your own dependencies if you under-valued your own program.  If you decided to charge only one cent for your Hello World example above with all those dependencies, you’re distributing someone else’s code for a small fraction of what it would be worth otherwise.  In this system each module author should be able to define a minimum cost for their library.  As this code gets included into parent projects they should honor this requirement.

The benefit of this minimum cost feature is that it will gradually increase the cost of increasingly-larger code.  If the total minimum cost for the mongoose module is $0.33 then the next author must charge a minimum amount which factors this into the total download price.

Final Thoughts

So why should we bother with a royalty-source code system when open source seems to be working fine?

  1. We’re not getting paid to create software
  2. Everybody expects us to be responsive to their own needs (fixing bugs/issues) without considering that we normally expect to pay for services rendered
  3. Corporations are using open source code as a means of not paying software developers
  4. Other than a virtual tip jar, there doesn’t appear to be anywhere within the open source system where the coder gets anything for their efforts
  5. It costs a lot of money to pay rent, to eat and to otherwise afford a working computer and Internet connection as a developer

flogging a dead horse

Many times in my career I’ve been at some technical crossroads which demanded a decision on my part:

  1. stay the course with some primary skillset I’d been developing or
  2. branch off on some new expertise.

If you think about it, that’s a pretty big gamble.  What will hiring managers be looking for two or even five years in the future?  What will look better on your résumé, a couple more years of experience in the old skillset or the old skills plus the two years of the new skills?  Is it possible that continuing to work with the old skill will now somehow look bad for your career?  But then, if you include too many skills does it look like you’re not focused enough on anything to actually have expertise?

Recognize Trends

I’d suggest that the following trends are appearing in the development playing space.

  • Java is no longer trusted:  Oracle’s Java was a good idea back in the early ’90s.  It allowed coders to write one set of programming which could be compiled and then distributed and run on a variety of platforms.  Several security-related issues with Java have forced many to outright ban Java from workstations within organizations.  Apple’s Safari browser blocks the plug-in for Java now and Microsoft Internet Explorer in newer versions disables Java by default.
  • Objective-C is a pain:  Apple probably should have replaced this language when it introduced iOS.  Since it only really is used for Mac OS and iOS development, a coder’s skillset in this language limits them to just Macs, iPads, iPhones and the Apple Watch.
  • JavaScript is the new black:  Open source and Node.js have invigorated the JavaScript language.  In the past it was only really used for client-side browser validations and such but today, it’s being used for almost anything on the client or the server.  PhoneGap allows cross-platform phone app development in JavaScript, threatening to destroy all competitors in this space.  In Tolkienian terms, Javascript is the one ring to rule them all.
  • C and even C++ seem dated now:  C (circa 1972) and C++ (circa 1979) are wonderful languages and yet they’re over thirty years old and that makes them seem stale to coders today.  C# (circa 2000) is now over 15 years old and is beginning to feel the same fate.
  • .net is only for Windows:  Even though Microsoft had originally intended .net to compete with Java as a multi-platform coding option, you don’t see this in practice since nobody has worked on a UNIX .net platform to allow this to take place.  The trend would be that single-platform solutions don’t have enough market share to ultimately survive the test of time.
  • Every day there are more coders entering this space:  Schools globally have been pushing technical careers over the last three decades.  Outsourcing websites and better English training and translation software are allowing people in other countries to compete more effectively with U.S.-based coders.
  • It’s not just keyboards and mice anymore:  Hand-held devices, touchscreen monitors and see-through goggles may be the norm soon.
  • Apps and stores (not programs and major versions):  It used to be that a new version of a program was delivered and a major update cost money.  An app now usually comes with unlimited updates and yet “in app purchases” still allow a stream of money for the developer.  In fact, these updates allow the developer another marketing opportunity to up-sell the customer something else.  Apple has made so much money with iTunes that Microsoft has completely re-tooled their own operating system to chase that same business model.  Google has done the same with their Android platform.

See the Future

To me, the future of coding will embrace anything that will allow one set of (familiar) code to be compiled to multiple platforms.

  1. Until the next “new, new thing” comes along, it looks like Javascript (in general) is for now the core language to know.
  2. Some interesting things appear to be coming from the Javascript ECMAScript 6 (ES6) standard.  When a sufficient number of browsers support it, this new standard (specifically) should be another good skillset to have.
  3. Node.js has enjoyed an amazing degree of implementation throughout the world in its short lifespan.  Knowing how to code to this would be in your best interest.
  4. HTML5 has been used in a fair number of high-profile websites, enough to ensure its popularity for a few more years.
  5. The github source code repository has over 30 million individual repositories in place and has built-in support in many other systems which can pull code automatically from it.  It looks like github will be around for a while.
  6. Several popular languages will likely be effectively dead soon for a variety of reasons:  Java, Objective-C, Visual Basic, C, C++, .net and Swift to name a few.

Be the Future

If you want a job as a coder in the future it’s time to start actively steering in the right direction instead of just passively continuing to use the platforms you’re now on.  If you don’t have the skills I’ve listed above then consider taking on a project to learn one or more.

If you’re currently embedded on a team that uses Java, for example, then I’d suggest that it’s going to be increasingly harder to find work elsewhere. Given that it’s becoming harder to find coding work now with all the competition it’s more critical to possess the skills that managers are looking for on a team.

open source

open-source adjective COMPUTING

denoting software for which the original source code is made freely available and may be redistributed and modified.


This is a big change for me, having made a career over the span of half my adult life as a software developer and usually getting paid for doing that.  In the U.S., here’s the timeline for software development:

  1. 1980-1985:  In its infancy, the earliest software developers made software for the novelty of it.  Nobody fully understood the value of computers and this software so a market didn’t really exist yet.  There wasn’t a lot of money to be made; it was a hobby and we knew it.  This early period ended in the mid-80s when business started embracing these solutions and were willing to pay for them.
  2. 1986-1999:  In its heyday, software developers during this next period would flourish.  The advent of the Internet and website solutions largely fueled this feeding frenzy.  Programmer salaries climbed to the point of six-figures for someone good.
  3. 2000-2013:  Abruptly in 2000 at the end of Bill Clinton’s last term, a huge number of software developer jobs were suddenly outsourced to foreign countries, chiefly:  India, China and Russia.  The U.S. still hasn’t fully recovered from the job losses sustained but businesses have learned that not all outsource promises actually pay off.
  4. 2014-current:  The current trend appears to be a movement away from the (licensed) Microsoft and Mac OS operating systems to any of a number of UNIX-based systems and especially browser-only software and phone applications.  Further, this trend continues with this “no fees” mentality by abandoning earlier licensing models completely.

From a personal-reward standpoint, the open source initiative has returned full circle to our earliest days.  You make software but you don’t do it thinking about the money.  Perhaps you hope that things will just work out and some money will land in your lap somehow.  Maybe this project will lead to a paid gig somewhere, who knows?  I think most young programmers are doing it to beef up their résumé and little more.

I think I would caution U.S. programmers, though.  It’s good to make free software and to make it available to other good people who do the same.  Please know, however, that there are corporations right now who are using open source to avoid paying software developers for their livelihood.  Corporations are using someone’s free labor as a means of saving costs.  I don’t think this is what the open source founders had in mind.

Corporations are using someone’s free labor as a means of saving costs.

Is this fair?  Having been a programmer for over three decades it doesn’t feel like it’s a fair playing field right now.

In order to compete in today’s market it seems like you need to program in the world of open source.  Given the current nature of open source this means that there are others who aren’t similarly contributing and yet who still enjoy the fruit of your free labor.  They’re making money and you’re not.  That’s not Capitalism, that’s essentially Feudalism.

The cost of maintaining a computer, a good Internet connection and keeping current on the latest software costs money.  Rent is expensive especially in the tech-savvy areas of our country.  The economy already is devaluing U.S. labor across the board and has done so for a little over ten years now.  In light of all this I have to ask the rhetorical question:

Why are we now giving away our high-tech labor for free?

It strikes me as a bad strategy.  Corporations outsourced a decade ago and then, presumably, learned from their lessons that outsourcing doesn’t produce quality code.  And now that we have this golden opportunity back young U.S. programmers have decided to enter the market without being paid for their labor, further devaluing the cost of software for everyone.

We can rightly blame corporations for being too greedy over the last decade.  But we then must blame ourselves if we decide to work without being paid as an industry.  Are we so afraid of the competition of outsourced foreign labor “on the cheap” that we have to fall suit and do the same?

But we then must blame ourselves if we decide to work without being paid as an industry.

If you want to contribute to the open source initiative (as I am) then I’d strongly suggest that you don’t give everything away for free.  Seriously guys, it’s time U.S. programmers found a better compromise with the consumers of software so that we can better afford to live here.