Media + Message = Carrier + Carried

In other posts, I mentioned a carrier and the carried. A media is composed of a carrier and a carried. We could be talking radio as a media, or a canvas and water paint as a media. The media being the carrier or the physical means. The sound we hear while listening to a radio: the DJ, the music, the advertisements; or the painted portrait or landscape as the message. The message being the content carried to by the carrier, the media. The carrier and carried, the media and the message are taken together inseparable in McLuhan’s quote. They are beat together and interact to become one thing composed of many things. Media turns up in the oddest places: software is a media, and in the technology adoption lifecycle.

Now when we automate a media like video in software, it’s obviously a media/medium. Or, when we develop a game, it too is obviously a medium. We even find ourselves in media categories competing with other media in the hopes of a big hit. We engage in a hit-based, front-end of the long tail, y-axis convergence, business that fundamentally doesn’t look like the software industry, or what we formerly called “tech.” Monetizing on display ads affects our businesses similarly. As a business, we are the business our monetization puts us in, not necessarily the software business. Display ads is a media proposition. The size of your audience matters more than your code.

But, walking away from that, ordinary software is a media. Software as a media is composed of carrier components both hardware and software, and carried content. It’s the familiar division between “What” (carried) and “How” (carrier) But, the division is messy. Too many people get this wrong, even when objects, data structures, coupling, and cohesion try to force some architecture on the issue. At the level of code the question becomes which is which? The index used when iterating through a list is carrier; the length of the list, possibly carried; the content of the list, carried if it originated in non-carrier domain. If the list is a list of commands originating  from the software itself, call it meta carrier, so it originated in the carrier domain. What is which is complicated.

Software as a technology gets adopted over time. Geoffrey Moore’s books, all of them, not just Crossing the Chasm, applied the Rodgers’ Diffusion of Innovation framework to the technology marketer’s work of creating a category and working through that category’s lifecycle. A category is created only for a new discontinuous innovation. Moore would have us begin at the beginning. Most of us don’t. These days, with the internet or devices, we start in Moore’s late main street phase. We start out post geek, where free is not a culturally driven demand, where customers will pay to play, where we, returning to the software as media model, are delivering the carried. The developers typically remain focused on carrier exclusively. Marketing should be focused on carried. The category’s lifecycle phase is focused on the carried.

If we started in the beginning, we would be serving the technical enthusiast, a carrier focused bunch. Then, we’d move on to productize our technology by building one client’s product visualization. That client being the B2B early adopter who expects to create a competitive advantage, value in depth, well off the interface. That client is a member of the vertical market we will serve later, both of which are carried focused. While developing this client’s application, we would include IT roles and spend increasing amounts of time on IT’s needs, carrier. We would have to split our efforts, so one team would remain carried focused, while another would be carrier focused. Then, after repeating this Early Adopter, Vertical, IT Horizontal sequence over and over in the bowling ally, we would cross the tornado in the early main street, where the focus would be carrier. Then, we would transition to the late main street that we discussed earlier. The phases are not short. That saves us. There is more to these phase shifts than just what happens with the software as media model. But, relative to the software as media model we move from carrier, to carried, to carrier, to carried. In the latter, we will end up seeing some of our technology commoditized, in which case, we will return to carrier to rectify that.

I covered the phase-driven changes, as they apply to the software as media model, a long time ago in a presentation, So you don’t have a market? Great!

So what brought this up tonight? A review of linear algebra demonstrated this same split between carrier and carried, this same split exhibited by software when seen as a media.

In integration, we come up with an equation of a family of equations like y=Ax+C, where C represents some initial condition that selects a particular equation from the integrals family of equations. In linear algebra, non-square matrices contain leading and non-leading columns. Those non-leading columns are set to a parameter. The leading columns contain variables the solution of which define a family of solutions. By providing specific values to the parameters, you select a specific solution from the family of solutions. The leading columns give us a class; the non-leading columns, an instance. Taking this back to the software as media model, the leading columns are carrier, and the non-leading columns are carried.

Those leading columns at like the control points of a Bezier curve. You can add control points without weighting them, without changing the curve. Later, with shock and awe, weight them, bending the curve-changing the carrier’s reach.

This all fell out of a discussion of row reduction. In a matrix undergoing row reduction, rows containing only zeros are moved to the bottom of the matrix. This reminded me of the distinction in game theory of dominated strategies, which don’t matter, and an be ignored when thinking about world size. Commoditization is one of those black swans where the world size shrinks and once discontinuous technologies become dominated having lost their differentiation. The rows hint at a stack with the top of the stack being the being the ground plane of the x-axis.

Well, enough of that, except it gave me the vision to see the carrier and carried layers of a media, software as media, a little clearer. Leave a comment.

One Response to “Media + Message = Carrier + Carried”

  1. Ito Processes in the Technolgy Adoption Lifecycle. | Product Strategist Says:

    […] have finite memories and infinite memories. But, we only have one memory. In my prior discussion of software as media, and in my TALC slideshare, […]

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

%d bloggers like this: