Will Microsoft Meet Occupational Programmer’s Needs?

Contents


Defining “Occupational Programmer

I made two posts recently that muddled serveral issues so I am creating a seperate post here to isolate them and provide a location for comments specific to this issue:

Microsoft is not meeting the needs of “Occupational Programmers.”

The first thing I should do is define the term “Occupational Programmer:

“An Occupational Programmer is one whose job is something besides programming. The programs they write are related to their main job such as streamlining tedious processes or automating labor intensive tasks. These people only spend a small percentage of their time programming.”

Professionals need Industrial Strength

Occupational programmers have significantly different needs than professional programmers or even hobbyists. Professional programmers need industrial strength developer tools. I could blather on forever defining that but I think most professional programmers know what they need as that’s what they focus all their time doing.

Hobbyists need to Learn

Hobbyist programmers main need is to learn. For them each learning experience grows on the past. Further, I would argue most hobbyist programmers are either younger (i.e. in elementary school, high school, or even college with a lot of free time on their hands) or older (i.e. retired and looking for something fun to exercise their brain.) I’m sure there are many hobbyists in between but I’d argue they are not the majority. Hobbyists goal is often to get better at programming, and I believe they are by definition both passionate about it and interested in learning in ways that occupational programmers simply are not.

Occupational Programmers need Productivity

Occupational programmers don’t have time to learn; they’ve got a real job to worry about. And occupational programmers often don’t care about learning the intricasies of programming at a professional level. Most importantly, occupational programmers don’t program frequently enough to transfer their learning from short to long term memory. Tellingly, Microsoft has a Coding4Fun website for hobbyists, but doesn’t have a Coding4Work website for occupational programmers!

Occupational Programmers need Discovery

Occupational programmers also need to be able to discover how to do things without lots of prerequisite knowledge. They need to be able to be highly productive every time the sit down to code. In that vein Microsoft’s “My” object is intuitive enough and addresses discovery.

Occupational Programmers need to Experiment

On the other hand, occupational programmers need to painlessly try things to see what works and not be distracted by lots of complexity. It is here where even Microsoft’s Express Editions fall short. They need a far simplier environment that allows them to type in a single line of code, highlight it, and then press a key to run it; no other prerequisites required. And if, for example, the code won’t run because of a missing reference the environment should pop up a suggestion based on an index of all available components on the user’s system, the occupational programmer should never be left trying to figure out where to go next to solve his problem.

In other words the occupational programmer needs a powerful interpreter but one that works more like SQL Query Analyzer than a command line interpreter. SQL Query Analyzer’s is it’s “canvas” that allows one to leave lots code lying around in various states of completion while it only executes the code that the user has currently highlighted.

Occupational Programmers need Progressive Disclosure

occupational programmers need Progressive Disclosure. They shouldn’t open up a development environment with numerous items competing for their attention. They shouldn’t have to worry about projects or properties or toolboxes, they should have a screen where they can start writing code and the equivalent of a (well designed) “Start” button and menu/wizard system.

Occupational Programmers need their Skills Grown

Additionally, the languages and tools used by occupational programmers should empower they to continually improve their skills without even trying, as they end up building significant systems over time. Some will even change careers to become full-time professional programmers eventually. If they are sandboxed with dead-end language and environment, think VBA or Visual Studio Tools for Applications, that’s no good either.

But Don’t Sandbox Occupational Programmers

And occupational programmers should be given the same languages professional developers use, but in a less-restrictive form; one potential example being a dynamic version of VB.NET with duck typing, etc. This is so professional developers can reuse and refactor the occupational programmer’s components and code. Occupational programmers have specialized knowledge that professional developers simply don’t have and putting them in two different sandboxes doesn’t make sense.

Focus on Languages and Frameworks, not GUI Tools

Further, the tool builders should focus on language and framework first, not the visual tools. Although this applies across the board for developer tools, it’s especially important to state related to occupational programmers because the tendancy is to just throw lots of GUI at less experienced developers, but that approach is fraught with peril (anyone remember Visual InterDev Design Time Controls?) I can acutally write a long post on this topic alone, and plan to, but suffice it to say that the focus should be on making it very easy to implement something in code using the language and the framework, and then create the visual tools to streamline this last.

Not Hard to Serve this HUGE Market

I believe there are tremendous number of occupational programmers out there whose needs are not being served and the irony is that I’m not proposing anything complex. On the contrary, Microsoft has partically all the technology it needs to build and ship the first version of what I’m envisioning within six months or less assuming a 3 to 5 person “SWAT team” that’s sheltered from politics (by 3 to 5 people I mean everyone; development, testing, documentation, marketing, etc.) It would be a tiny investment, and if it was released below the radar and sans Microsoft’s full hype machine it’s benefit to prospective users could be evaluated before they committing Microsoft to supporting any legacies it might create. And Microsoft could call this tool “Power Developer” (I chose that name because of PowerShell.)

There’s a lot more I could say on this issue (and I’ve said some of it in the past), but I’ll leave it at this and await your comments.

Other References

P.S. Here are some posts I made over 2.5 years ago on this and related subjects:

And these are some posts over people have made and/or posts with related comments, in no particular order:

I’m Available…

P.P.S. If any decision makers at Microsoft are listening but don’t currently have the right person on the inside to champion this idea, they should be aware that I am, at the time of this writing, available to help. :)

 

Clarifying my Microsoft Developer Division Rant

Contents


I Ranted and Eric Rebutted

The day before yesterday I wrote a long winded and rambling rant about how Microsoft’s release cycle and process for creating developer tools. I commented on how I believe it is making them fall behind and causing many formerly loyal Microsoft developers to look at open source solutions on non-Windows platforms. I referenced a post that Microsoft’s Eric Lippert wrote over 2.5 years ago titled Top Minds Are Working On It[1]. In retrospect it might have appeared I was being critical of Eric but that wasn’t my intention, and if that’s how I came across I apologize. Instead I was referencing Eric’s comments as symptomatic of the Microsoft culture at large. And yesterday I awoke to find that Eric had issued a rebuttal.

While I Respect the People at Microsoft…

But before I address his comments let me talk about Eric and all the others I’ve met from Microsoft. Eric is actually a brilliant guy, and very likeable. I’ve met Eric face-to-face and it’s obvious he’s much smarter than me. But then I could say that about most of those I’ve met from Microsoft; they don’t hire dummies. As a rule I’ve been impressed with every Microsoft employee I’ve met. They are super bright and AFAICT they do really want to do "Good Things(tm)".

…They Become Detached

But group dynamics being what they are, when you get a group of super-bright people together they become competitive, hone their debate skills, and learn to be strong advocates for whatever their own positions. And they can become detached from the outside world, much like politicians in high office. Politicians are also typically super bright, and most enter office wanting to do Good Things(tm), but once "on the inside" they loose touch with the concerns of their constituents. So I am not condemning Eric and his Microsoft colleagues, I am merely commenting on the culture that results and collectively channels them.

Eric Unconsciously Supports my Thesis!

So I started yesterday’s post saying I’d been planning to blog on the topic for a while but the reality was I still didn’t know how best to explain my concerns. But for better or for worse I did write a rambling essay yesterday, but ironically Eric’s comments made my points far better than I! My central thesis was that Microsoft isn’t meeting developer’s needs because of their processes and infrequent releases and consequently open-source alternatives are meeting developer’s needs instead. Eric’s both debated my examples and pointed out they now plan to address some issues I referenced. But not only did Eric not address my central thesis, he ironically supported it given his rebuttal’s choice of focus! In my post I wrote the following:

"Microsoft’s culture is to argue semantics when reality doesn’t match their world view"

And Eric’s comments proceeded to do exactly that! In my post from 2.5 years ago[1] I called for Microsoft to address things that PHP, Ruby, and Python are addressing today, which Eric rebutted at the time. In yesterday’s rebuttal Eric referenced his earlier comments stating (emphasis mine):

"Second, my ‘esoteric’ reasons for not implementing a scripty version of VB on the .NET platform were hardly esoteric then and are hardly esoteric now. They are (1) fracturing the language further causes confusion amongst customers and is massively expensive for little gain, …"

Dismissing the Proposal, Not Solving the Problem

Now I’ll freely admit Eric is far more qualified to evaluate my suggestion on technical merit, but that wasn’t the point of my 2.5 year old post. Customers with needs a company’s not addressing will often propose solutions they believe will address their needs, yet often their suggestions aren’t workable for whatever reason. People who specialize in addressing customer needs know that rather than dismiss suggestions as unworkable it’s far better to determine the customer’s actual needs and implement a workable solution instead. And often, many other customers have those same needs. So Eric dismissed my proposed solution but didn’t address my unresolved needs that prompted the proposal. I don’t attribute this failing to Eric, I attribute it to Microsoft’s current culture.

Not More Power; Transitionality!

Eric then went on to say:

"(2) we can do things to make VB.NET more powerful without fracturing the language,…"

Ironically, I didn’t ask for a more powerful VB.NET; I asked for one that was easier to start using and one that developers could then easily transition to more powerful usage. Though they believed they were providing an easier to use Visual Basic 2005, they addressed the language but not how people develop applications. Though they made strides with the Express Edition, my biggest concern was with the complexity of the development environment and the language. I suggested an interpretive environment with a transitional language design that allowed new developers to start easily yet be able to effortlessly grow their expertise with use. What I envisioned was something like Boo, but I wanted it 2.5 years ago with a simple interpretive environment, and I wanted it from Microsoft so that it could possibly generate a large and immediate and user base with a thriving community and significant peer support.

Today’s Potential Didn’t Address Yesterday’s Deficiency

Eric continued with the following…:

"(3) Microsoft makes scripting languages like Iron Python"

…but omitted the fact that a robust Iron Python was just a gleam in Jim Hugunin’s eye 2.5 years ago and is still not ready for prime time. Further, Microsoft’s approach is to host IronPython in Visual Studio which does nothing to bypass the complexity of Visual Studio!

Nor Does an Orphan Address Yesterday’s Deficiency

Eric then said:

"…and JScript .NET, use the right tool for the right job."

To which I did a double take wondering if he were really serious! JScript .NET is such the orphan that I can’t even believe he suggested it! The JScript .NET newsgroup has less than a screen full of messages, JScript .NET hasn’t been updated since 2003, and nobody’s even written about JScript .NET in years! So could Eric really have been serious when he suggested JScript .NET? Well, assuming he was, then:

  • JScript .NET does NOT have an easy-to-use interpretive environment, and
  • JScript .NET is a complex language; NOT simple-to-use, and
  • Again, JScript .NET has NO user-base!

And a Potential isn’t a Solution

Moving on Eric said:

"The .NET framework is already amenable to the development of scripting languages."

So why do we still not have a viable scripting solution for .NET supported from Microsoft more than half a decade after the .NET Framework’s first release?

Yes, there’s Powershell, but…

Okay, that’s not quite true. Eric didn’t mention it but in the spirit of honest debate, there is Microsoft’s PowerShell. But while I will freely admit PowerShell is really nice, PowerShell:

  1. Was only just released so doesn’t address the past 2.5 years,
  2. Doesn’t have a development environment,
  3. Can’t be used for web development,
  4. Doesn’t have a compiler for creating components for use in other .NET languages.
  5. Doesn’t have transitionality allowing it to scale up for much more complex projects as the developer’s experience grows.

A Correct yet Irrelevant Point

Eric then makes a point about "scripting languages" vs. "dynamic languages" (emphasis mine):

"Third, I want to make a distinction between scripting languages (languages intended to script things) and dynamic languages (languages which admit a type system which cannot be deeply analyzed at compile time.) Scripting languages are often dynamic languages, however it is entirely possible to use dynamic languages for tasks other than scripting. "

Okay… So Eric’s points are very technically valid, but they are totally irrelevant! Frankly I wasn’t asking for a language that was "intended to script things," I was proposing a language (and IDE) that would be:

  1. Productive,
  2. Easy to start using, and
  3. Scalable as one’s skills evolve.

Call it "scripting", call it a "dynamic language", call it whatever; it’s irrelevant. What is relevant is for it to be productive, easy, and scalable. Microsoft could choose to get there however they will, bit like arguing the semantics of "Car" vs. "SUV" with someone who just needs transportation, Eric’s distinctions were simply irrelevant to the needs. Totally unrelated, I ran across this joke yesterday. What could be more ironic?

Interest Doesn’t Necessarily Change Process

Eric finishes his prior point with:

"The VS team is VERY interested in understanding how to make the platform more amenable to dynamic languages."

Great! But are they going to actually engage people who are not .NET developers in the design of said dynamic languages and their respective development environments and then incorporate their feedback? Or is the VS Team just going to plug another dynamic language into Visual Studio? If the latter they will do so ignoring that Visual Studio users already have the language(s) they need and that there are at least an order of magnitude more people for whom Visual Studio is too overwhelming.

A Solution Offered; Wrong Product, Years from Now

A couple other comments Eric made were:

"C# 3.0 will have the "one line auto-implemented properties" feature you requested for VB. Enough people asked for it, we put it in. I do not know if VB will be doing the same. You’re welcome. "

and

"Current C# 3.0 features move in the direction of dynamic languages without actually making the language dynamic (lambdas, improved generic method type inference, extension methods, implicitly typed locals, anonymous tuple types). All of these however are implemented so as to keep the language statically analyzable. We are considering features for C# 4.0 which would make the language more dynamic without losing that important statically analyzable core."

That’s well and good, but it doesn’t address VB.NET, and it also makes my own point that Microsoft’s release cycles are too far apart! There are badly needed enhancements and they need to get them to developers more often than once every three years. C# 3.0 is still a way’s out, people need something today, and I personally wonder if I’ll even care about programming by the time C# 4.0 is released. Hell, I hope to have made my fortune and be retired by then! :-) But seriously, C# is a professional developer’s language and adding features to a professional developer’s language wasn’t even close to what I was proposing.

Too Little, Too Late: Acknowledged

In the last paragraph, Eric finally gives tacit acknowledgement of the concerns I raised in yesterdays post:

"Now, maybe these features aren’t what you want, or are too little too late, or the release schedule is too long for your liking, or whatever. That’s unfortunate."

Exactly. The release cycle needs to be compressed by an order of magnitude as it has been at the competition. More on this in a bit.

Studying Users Isn’t Feeling their Pain

Eric then signs off with:

"However I take exception to the claim that we do not study what real users are doing and try to provide tools that do what they want. We do that every day."

With this Eric either misunderstood my point, or more likely I didn’t state my point in a manner that was understandable. Whichever the case, let me clarify. I know the VS Team works hard to study real user’s needs every day. But what I also know is that the people who make the decisions about what gets released and when have considerations that are far different from the needs of developers. And it is human nature for one to place solving one’s own pains ahead of solving the pains of others as people simple can’t fully comprehend pains they don’t experience.

Trade-offs that Shortchange Developers

Eric let’s be concrete; if solving a customer problem today will cause the VS team a problem tomorrow they won’t do it. For example if the VS Team plans to rearchitect something next version they won’t provide an interface that developers need in this version if doing so will make that rearchitecture difficult. Some would say this is good product engineering to which I would actually agree, but it is nonetheless a trade-off that keeps developers from getting what they need today.

Experiencing Pain Empowers Real Solutions

So, if you’ll reread my post from yesterday you’ll see that I didn’t say "Microsoft doesn’t listen to customers"; I know damn well they do. On the contrary, I said that Microsoft’s Developer Division "Don’t solve real world problems." And the reason you don’t is because you don’t experience the pain that those real world problems cause. By comparison most developers contributing to open-source projects are doing so to solve pains which they themselves have, and that is why they are addressing developer needs much faster than Microsoft’s Developer Division.

Yes it is a Paradox…

An observant person would say that I’ve present a rather intractible dichotomy for Microsoft’s Developer Division; i.e. they need to use the developer tools they build to solve real world problems yet they also need to to develop those tools ten times faster! Now I’m sure these comment will cause the blood of those in Microsoft’s Developer Division to boil thinking I believe it’s possible they do their work ten times faster and do real world projects. But I was not advocating that; I’m fully aware of the myth of the "man-month" in software development projects.

…But Solve it You Must, Or Else

What I was pointing out, however, is if Microsoft’s Developer Division maintains its status quo they will slip farther behind and the loss of developers to other platforms will accelerate. And since developers, developers, developers have always been Microsoft’s life blood it is critical they address this issue. Every developer they loose to Linux or the Mac doubly weakens Windows. Microsoft must address this issue if they are to maintain the same level of relevancy during the next twenty years that they’ve had for the past twenty years. And most of what I’m suggesting isn’t complex, and it isn’t new. They probably have most of what they need already written and used internally. They just need to rethink what they are offering.

Change, or Be Changed

So to wrap up this second long-winded essay:

Microsoft’s Developer Division needs to implement drastic changes sooner than later. If they do not, outside forces will soon impose drastic changes upon them and it’s certain they will find those imposed changes to be far more painful. Or as the mechanic on the old Fram Oil Filter commercial used to say "Pay me now, or pay me later."

What if I’m Not Wrong?

P.S. If you’re from Microsoft’s Developer Division and choose to dismiss my concerns, just ask yourself this: What’s the downside for you if I’m right?

  1. Eric Lippert’s post was in response to my post entitled A Modest Proposal: VBScript.NET, aka "Helping Mort use .NET".

 

Mort, the “Hobbyist”, and the “Occupational” Programmer get their due

Wow!

Several months ago I blogged about the need for a much simpler way to get into .NET, and I named my proposed solution VBScript.NET (in hindsight the name was a poor choice because people assumed I was proposing porting VBScript to .NET instead of providing a simplified VB.NET, but highsight often is 20/20…) And I was not the only one, lots of others blogged about the same topic (see here, here, here, here, here, and here to list a few.)

It looks like Microsoft was listening after all! Check out the New Visual Studio Express products, in beta at this point! I haven’t downloaded any of them yet, and I don’t know if they’ll address all the issues my proposal was meant to address, but even if not at least they are trying!

Kudos Microsoft!

UPDATE (2007-01-01): I’ve since come to the conclusion that the Express Edition still does not address the needs of the occupational programmer.

Why .NET needs the (option of) less strictness

First, I’m honored Paul Vick was willing to read my long-winded essay, and second I’m honored he would blog about it.

In this blog post Paul wrote:

…Mike also raises the question of strictness. He makes the argument (echoed by Don Box and others) that many programmers would do better with a world that’s more typeless and less strict than the one they get on .NET. As someone who lives day to day in a strongly-typed world (so to speak), this seems somewhat counter-intuitive: less typing usually equals less performance and less compile-time checking, leaving problems to be discovered at runtime. In fact, one of the major features of this release, generics, is specifically about making it easier to have *more* type safety and better performance at runtime. So the persistent voices in favor of scripting appear to be swimming against the tide. The question is: are they right?

Is Strictness Bad?

Let me clarify my point about less strictness. I for one absolutely love strictness; I think it makes far more robust applications possible. .NET is fabulous; I still program some in ASP/VBScript and I see so many things about .NET that I wish I could use.

So the cry for less strictness (at least from me) is not a belief it does not have value but instead about the minimum skill requirements for someone to become minimally productive. Every additional bit of required strictness adds one more thing for the person with few or no skills to learn before they can get started. “Occupational“/”Hobbiest” programmers (Matts and Morts) have short attention spans (!) because they have to get a job done. If learning to IMPORT this or CTYPE() that takes more than a few minutes, they’ll most likely give up and do without or go elsewhere (god forbid!) 

I don’t want to let them become sloppy coders, I just want to see you lower the initial barrier that currently keeps them from getting started.

Strictness is Good, but we need Accessibility and Transitionality

No, it is not wanting less strictness, it is about wanting .NET to be more initially accessible. When your parents first taught you to ride a bicycle, didn’t they give you training wheels? It would have been a lot harder (with a lot more skint knees) without! Do you use training wheels on your bike today? Of course not. Did you ski the black diamond on your first ski trip? (I hope not.) Did you get a learner’s permit when learning to drive a car? Were you able to windsurf within the first minute you tried? Don’t governments require hours and hours of practice with a skilled instructor onboard before they allow you to fly a plane solo?

Life is full of things that require signficiant skill, but life has many ways to achieve those skills without requiring initial mastery. Programming in .NET requires a lot of knowledge and skill yet .NET offers no training wheels.

So I am not arguing against strictness, I’m arguing for the option of less strictness because that is what is needed to make .NET more accessible to hobbyists and occupational programmers.

But don’t Send them Adrift without a Paddle

However, I also believe the option for less strictness should go hand-in-hand with a strategy for providing transitionality. Many years ago a Microsoft Windows NT Server program manager whose name I cannot remember told me “scalability doesn’t just mean scaling up.” Similarly transitionality isn’t just about making it easy for the beginner. Transitionality is also about making it easy for the beginner to become an expert.

A transitionality strategy from Microsoft should incorporate messaging and education. It should not only promote how easy .NET is for building small solutions with lax strictness, but it should also promote how important it is for people to learn strictness and incorporate into their apps, especially if those apps will grow in scale. I think this education is important to pre-empt those not classically educated in computer science from developing ignorant biases against strictness.

A transitionality strategy should also incorporate methods of helping the beginner learn by example. In my VBScript.NET essay, I talked about an IDE and/or script-processing EXE that would show VBScript.NET code after it was converted to fully decorated VB.NET code complete with all strictness options so people can easily see how it could/should be done using their own code as the example. If you’d like more examples, see any of my other posts on transitionality as they all cover this concept in one way or another.

And don’t Fragment Expertise

One last point I think it is important to make based on some of the response I’ve seen to my VBScript.NET essay. It is critical that whatever Microsoft offers to make .NET more acccessible is also compatible with its core .NET programming languages, and minimally I think that means VB.NET.

As I tried to get across in my essay, my concept for VBScript.NET was not a new language. It was not a proposal for a .NET version of VBScript. Instead I proposed a lexically simple dialect of VB.NET layered on top of VB.NET with tools that made it easy to use. Tools such as a simple IDE that would show VBScript.NET code converted to VB.NET and a “script processing” EXE that would minimally execute just one or line of code without requiring projects or namespaces or references or that big honkin VS.NET.

Everything a .NET beginner learns should add to his .NET skill, especially in the library and language, though less so with the IDE and tools. That is where I believe VBScript, VBA, and VB6 went astray; expertise in one did not necessarily translate to expertise in the others.

The Bottom Line Goals

I’m not married to my idea for VBScript.NET. The same goals can be acheived numerous ways. I’ll summarize the goals I see:

  • Make .NET more accessible to beginners by relaxing strictness
  • Provide transitionality to allow .NET beginners to become .NET experts
  • Offer tools that simplify use and “tutor” .NET beginners toward .NET expertise “by example”
  • Ensure beginner .NET offerings are upwards compatible with expert .NET offerings
  • Ensure everything a .NET beginner learn adds to their .NET expertise

So Paul, does this not shine a new light on what I have been proposing? BTW, I really do like your longer posts. They are much more interesting than the short “look there!” type of post by most bloggers.

Woe be it for the Hobbyist Programmer

I just came across a blog entry that disturbed me entitled Should the hobbyist programmer matter to Microsoft? by Rory Blyth of Neopolean.com. It was not so much the blog entry by Rory that really disturbed me, but the tone of the comments he received (over 100 at the time.) As I started writing this post, I planned to comment on those comments. Instead, all my comments instead focused on Rory’s post. Maybe I’ll comment on the comments in a future blog.

Divining Microsoft’s Responsibility

Rory was commenting on Kathleen Dollard’s Guest Editorial at Visual Studio Magazine entitled Save the Hobbyist Programmer (I think it regrettable that Kathleen choose the term “hobbyist programmer” rather than something like “occupational programmers” because the post’s comments seemed to attack more of what the term “hobbyist” implies than the actual concepts it seems Kathleen was trying to convey.) In his post, Rory starts out by saying:

Microsoft’s responsibility is not to hobbyist programmers. As someone who makes his living by working with Microsoft technologies, I would be rather ticked off if MS were catering to people who weren’t professional coders.

I found that quote most interesting because nowhere in his post did Rory reference Microsoft’s corporate by-laws, mission statement, or analyst presentation where thye indicated they had explicitly chosen to avoid meeting the needs of “non-professional coders.” As far as I know, Microsoft has issued no such statement of direction so I’m not sure why Rory would state Microsoft’s responsibility is not to hobbyist programmers. Has he been speaking to Gates or Balmer and just not told us?

She turned me into a Newt!… Well I got bettuh.

Continuing, Rory goes on to state:

I’m not so sure where the increased complexity is. I did quite a bit of VB6 programming before moving to .NET. I found the switch to be a bit of a shock, but when I was over the hump of getting accustomed to .NET, I found my job much easier.

Odd. If there were no increased complexity, what “hump” would there have been to get over?

Compare apples and oranges; they are both eaten

In his post Rory also implies an analogy comparing an older vs. newer car with the hobbyist programmer vs. the professional programmer:

Making changes to accommodate the tinkerers would be like rolling back advances in auto engineering. My car is held together by more electronics and gizmos than you’ll find at NASA Mission Control. I can’t change my own oil, and I sure as hell wouldn’t try to yank a spark plug out. Although I’ve been denied the chance to put my car on blocks and work on it over the weekend, I’ve been granted an automobile that is much more efficient, reliable, and powerful than I would have had if it had been built with accessibility to non-mechanics in mind.

I tried to understand this analogy, but I just could not get it to fit:

  • Changing oil and spark plugs is routine mechanical maintenance. Programs have no mechanical maintenance. Assuming programs are designed correctly then never “wear out.” There is simply no equivalent in software for the changing of oil or plugs.
  • Automobiles were generally designed to address a common use case: transportation. As designed, they meet the needs of most people who use them, although probably never perfectly but almost always good enough. Automobiles are far more analogous to applications like Word and Excel than to development tools which are designed to create software for new use cases.
  • It is simply not possible for one person with only intellectual resources to modify or create a new type of car to meet new use cases.
  • In the automotive field, the better analogy with development tools might be the tools required to fabricate new automobiles. Still, the physical requirements of creating an automobile to meet a new use case vs. the lack of such requirements for programming seem inexact analogy at best.

Maybe another analogy would be the professional drivers whose job it is to use cars (and trucks) to transport people or things from one location to another such as truckers, taxi drivers, package deliver drivers, and so. By comparison there are many non-professional drivers who also transport people or things by cars (and trucks.) We could possibly imagine a professional driver saying about General Motors:

General Motor’s responsibility is not to hobbyist drivers. As someone who makes his living by driving General Motor’s vehicles, I would be rather ticked off if GM were catering to people who weren’t professional drivers.

It would seem that might not make the most sense for GM as its market for drivers who transfer people or things from one location to another is larger if it does not ignore the “hobbyist” driver. I won’t further comment on this.

Mommy, where do “Professionals” come from?

Elsewhere in his post Rory states:

Gone was the horrible combination of procedural and OO programming styles. I no longer wrote code that made use of some mysterious global function that existed in god-knows-what library. My web applications are no longer monolithic pages of stand-alone code that’s about as reusable as a condom. Life is better.

Strange. By implication Rory states he is a professional programmer, but my understanding is that if one is a professional programmer one wouldn’t large monolithic modules of stand-alone code that are not reusable. But maybe that is naive on my part as technically the definition of “professional” means “they get paid to do it.” So maybe “professional” doesn’t mean one is actually reasonably skilled in their profession?

But maybe that too would be an unfair interpretation. Maybe when Rory used the term “professional programmer” he meant someone who has developed a level of skill and expertise in the area of programming, and someone who would be considered a “professional programmer” by others holding the same designation. That’s probably what he meant?

Assuming that definition, let’s revisit Rory’s last quoted statement above. Is it possible that Rory was not always a professional programmer but instead actually learned his skills over time? Maybe Rory is now a skilled professional programmer, but earlier he was not? That would seem logical as I don’t believe on the day of one’s birth, a person has ever left the mother’s womb carrying with them the designation of “professional programmer.” (please post comments and provide references if any readers know otherwise.)

Based on that postulate, wouldn’t logic dictate that the state of being a professional programmer would require a transition from being something less of a professional programmer? Further, it would seem logic would also dictate that is it not possible to instantaneously transition from being “not-a-professional” to being a professional if being a professional by definition requires expertise?

If my logic is all correct, that would then explain how Rory could be consider a professional programmer now yet at one time his code was previously “implemented using a horrible combination of procedural and OO programming” which is inconsistent with how a professional programmer would implement code. Clearly in the past he was not (as much of) a professional programmer as he is today?

The logic would also appear to reveal that there are not just two states, one of being a “professional programmer” and another being a “hobbyist programmer“, but instead an almost infinite series of states in between the two extremes. Given that, it would follow that it would be very difficult to determine just exactly to whom Microsoft has responsibility, assuming there was some way to determine, in this area, just to whom that specific responsibility would be.

Since any given state along the continuum between hobbyist and professional is infinitesimally small, how could Microsoft limit its target focus to one exact state along the continuum? Given the costs of creating and supporting development tools, would not Microsoft be required by the laws of economics to provide tools that could be used by a broader range of programmer’s along the continuum?

If so it creates the quandary of where to stop along the continuum as one targets professional and expands target toward hobbyist. Since all it is that appears to limit the hobbyist from the professional is skill and expertise, then would not catering to the hobbyist in turn generate more professionals since the hobbyist becomes like a professional each day programming? That would tend to support the earlier argument that a programmer transitions from being not-a-professional to a professional over time.

Divining Microsoft’s Responsibility, Redux

To finally bring this all to closure let’s consider the modern publicly-held corporation in a capitalist society. My understanding is that such a corporation’s primary responsibility is to its shareholders, and public company shareholders generally want, all other things being equal, for the share price to be increased. Since Microsoft is a modern publicly-held corporation in a capitalist society, it would seem Microsoft’s responsibility is to its shareholders and hence to increase the price of its shares.

In the past, ignoring government intervention, Microsoft has proven itself rather adept at increasing its share price (I personally am glad I bought Microsoft shares many years back, which I have since sold at a gain.) I think it can be argued Microsoft’s strategy’s for increasing its share price have generally been to increase the installed user base of Windows.

Further, I think it is reasonable agreed computer users generally purchase computers because they provide applications that provide the users with some level of value. Since developers create applications, it would seem empowering developers would help increase the number of applications available. Simple math would then imply that the more people developing applications for Windows, the more potential users would find applications for Windows they would value and hence be more likely to purchase Windows from Microsoft. Further it would seem logical that users would be more likely to value applications developed by programmers whose skill and expertise levels were greater because those programmers would be more likely to create programs of higher quality.

Given all of these postulates and theorems, it would seem Microsoft’s best strategy would be to focus on creating as broad a base of programmers as possible, and enable as many of them as possible to move from “hobbyist” to “professional.” Doing this would be most likely to increase the number of quality applications available for Windows, which would likely increase the number of people buying Windows, which would likely increase Microsoft’s share price. Would this not be the most logic strategy for Microsoft given the analysis?

How I see it

Assuming I have not made any logic errors in my prior analysis, it would then seem that, regarding Microsoft’s “responsibility“, the following could be said:

Microsoft’s responsibility is not only to professional programmers but also to hobbyist programmers, and all programmers in between. Anything less, as a modern publicly-held corporation in a capitalist society, would be a dereliction of their duties to their shareholders to whom they have ultimate fiduciary responsibility.

Anyway, that’s how I see it. :-)