What do I think of when considering ‘user experience‘ for the technical folk? What makes it easier to do their jobs? What helps them do their jobs better?
Techies include the following sorts of resources.
- Dev Ops
- Program Operators
As always, common factors that I listed in the post, User experience in an enterprise system, apply to these resources as well.
Programmers can see everything
Interestingly, it appears that programmers occupy a special place in the enterprise. Everything, systems and data, that any corner of the enterprise sees and uses, must be accessible to some programmer or the other. Who builds these systems? Programmers. Who do you call when anything goes wrong? Programmers. Nothing can be hidden from the programmers.
This means that the the user experience considerations that apply for everybody else in the enterprise, which I have written about in other posts, apply to programmers as well.
One thought occurs to me. Doesn’t this kind of all-pervasive access raise privacy issues? Not to mention security concerns? I wonder how enterprises deal with this.
A Domain Specific Language (DSL)
Often, for some reason or the other, a programmer is asked to perform a business task. The enterprise system typically supplies business users a graphical interface for this work. Programmers can use that interface too. However, programmers have technical skills that typical business users may not have. Further, programmers have responsibilities other than performing business tasks, which means they are looking to save as much time as possible.
Hence, if it is possible to provide programmers an alternate interface, which is more powerful, and more performant, even if more technically complex, it would be a good thing.
In some of my previous work, programmers did considerable customer support work. Often they would have to perform some activity that meant wading through pages and pages of UI, in order to make one small change, or press one button. I heard them lamenting the lack of a more ‘expert’ kind of interface. After all, they arguably had more technical expertise than the rank and file business users. We could have used a scripting solution. A couple of lines of a well designed DSL (domain specific language), would have put them all in a good mood, not to mention saved a lot of time, and energy.
Say that you have to change the type of roof, on the 3rd barn of the farm that is insured by farm policy, FU-237EKS. After the change, the policy must be assigned to an underwriter for review. In the UI, the change happens on the 8th screen of the farm policy. The assignment to the underwriter is a further 3 screens down. Rather than schelp through all that UI, some folks I knew would have liked to execute something like this script.
FU-237EKS.barns.roof = shingle
underwriters['nate silver'].reviews += fp237eks
However, keep in mind that it ought to be possible to design the graphical user interface so that it provides the same kind of power, and efficiency. The recent, industry-wide emphasis on usability is all about this kind of improvement. The point here is that alternatives to GUIs (graphical user interfaces) exist, which might more naturally fit programmers’ sensibilities.
I also wonder if there might be certain kinds of business functions that are hard to represent in a GUI. Some complex, but one-off, workflow, which has to be created on the fly, for instance. This is a question to explore.
Some items related to support
- You must be able to change the logging level that is in effect without stopping the application.
- You must be able to add muscle to the system, without stopping anything. Bring more servers on line, add more threads to a running server, and so on.
Software Configuration Management
Essentially, all of configuration management must be automated.
Check out, and check in of code; build, test, assembly, and release of an application, must be completely scriptable. You should be able to do all of this at a click of a single button, or the issue of a single command at the command line.
In some of my previous work, even though the code base was all in one source control system, we used to have to explicitly issue about 60 check out commands. We never automated the check out. So to
create a new workspace, we would do a lot of manual work – 60 clicks of the mouse, 60 commands at the command line.
Releasing a new version of the application was a multi-step, manual process, which would require some Dev Ops person to be up at ungodly hours.
Some releases, especially emergency patches, were horrendously complex. Some poor schnook, sitting in India, used to have to painstakingly undo changes to several parts of the code base, make the release, and then restore all those changes.
Needless to say, this was error-prone. Disasters, big and small, begging to happen. This should never be the case.
Software configuration management (sometimes referred to as build management, release management), must never be a burden to the developer. Folks that specialize in this work (Dev Ops), must hide the complexity by automating it all away. If you are using tools that do not lend themselves to this kind of automation, well, you are using the tools that developers cannot love. This is infrastructure, which is meant to remove some of the drudgery from a developer’s working life. So let us have useful, and reliable, infrastructure.
One of the most critical lessons of the Agile philosophy is the recognition that developers must also test. The Agile world asks, how does a developer know he is done with a task? The Agile world answers, he proves it with tests. When all of his tests run successfully, the developer is done with his work.
Each developer must be able to test her work independently of other programmers. This means that each developer must have separate sandboxes for code, and data.
Developers have their own sandboxes for code by virtue of using a
source control system. However, in my previous work, I often
encountered resistance to setting up independent sandboxes for
the data. I never really understood this. Why couldn't each
developer have their own copy of the system database for instance?
Isn't this sort of thing quite inexpensive these days?
We must automate the generation, and load, of test data.
In one of my previous jobs, many tests required testers to create an
insurance policy. These were manually entered, a laborious process,
which took significant time.
As you can imagine, testing was not as rigorous as it could have been,
because it was just too hard to setup the data required for the test.
The system’s user interfaces must support automation. This is necessary not only for functional testing, but more importantly, for load testing. You have to be able to simulate many users banging on the UI. For this to be done with any kind of rigor, you have to be able to drive the UI with scripts. Keep that in mind when you construct the UI.
Tests must run continuously. If you have ‘continuos integration‘ going, you have this in place. Continuous integration is a feature of software configuration management. Every time a change is checked into the source control system, you must automatically kick off a build of the whole system, which, by definition, includes tests. This allows you to find errors sooner rather than later. Continuous integration is possible only if all of your software configuration management is automated.
Finally, a replica of the production environment must be available to the developers. Often, you run into errors that only seem to happen in production. Give developers an environment that is identical to production, where they can test, and debug problems, without messing with the production environment itself. Without this, you are asking developers to be brilliant, which seems like a high risk strategy.
Techies other than developers
So how about testers, dev ops personnel, and program operators? These folks perform functions that have been covered above, and in earlier posts.
The section on testing applies to folks that are exclusively black box testers. The section on configuration management applies to dev ops. Earlier posts on graceful processes applies to program operators.