<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Stephen Kress on Medium]]></title>
        <description><![CDATA[Stories by Stephen Kress on Medium]]></description>
        <link>https://medium.com/@jskress-8494?source=rss-a1182d43be92------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*DlA5T_j9Oko8XRnfOBU8Wg.png</url>
            <title>Stories by Stephen Kress on Medium</title>
            <link>https://medium.com/@jskress-8494?source=rss-a1182d43be92------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 08:58:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jskress-8494/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Real UX Problem]]></title>
            <link>https://jskress-8494.medium.com/the-real-ux-problem-8afb96e811cd?source=rss-a1182d43be92------2</link>
            <guid isPermaLink="false">https://medium.com/p/8afb96e811cd</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[user-experience]]></category>
            <dc:creator><![CDATA[Stephen Kress]]></dc:creator>
            <pubDate>Wed, 14 Oct 2020 22:42:56 GMT</pubDate>
            <atom:updated>2020-10-14T22:42:56.949Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Computer terminal session" src="https://cdn-images-1.medium.com/max/1024/1*drI_O-CRDrRCQXiLtYqsRA.png" /></figure><p>In my first story, I introduced you to a gap I see between what we, as software development professionals, build and what our end users actually need. We’re going to explore this in a bit more depth here.</p><p>I hinted at but was not particularly detailed about the core problem, that of a consistent UX across <em>all</em> the things that a user does with a computer. Remember, and this is key, that the user has to use more than one tool, in general, to get their job done. This leads to some interesting problems.</p><p>First, very often the user is so busy trying to get their actual day-to-day job done that, paradoxically, they have no time to learn these cool tools we developers create for them. They get stuck in a catch-22, leading to frustration and an even lower desire to learn new tools. It doesn’t help that, because of how software is developed, there is never 100% alignment between what the development team has created and what the user would actually find useful. I have seen many, many times where training for software includes working around the places where the software doesn’t support the company’s desired processes in some way. Is it any wonder that those in charge of actually getting things done end up shoehorning processes, data management, and the like into things like documents and spreadsheets? They are certainly not well suited for most of what people actually do with them but they do provide a UX that most of us know and are even fairly comfortable using. It’s important for us to realize that this is so crucial to those decision makers that they don’t care they are usually sacrificing security and the ability to audit the system (!!) in favor of using software that requires little to no training. They have learned the hard way that the best software is completely useless if the user base cannot or will not use it.</p><p>Another problem is one I covered in my last story. Since each individual tool is typically built in isolation, users end up with a very choppy experience as they need to switch between them. At first glance, you might expect this to be a nearly impossible problem to solve, especially since tools can come from different vendors (at that point, we’re dealing with different ideas about how things should look, how they should behave and even what’s important for the user to see). I would suggest, however, that we’ve gotten this right about 1 1/2 times in the whole history of computing (not a great average but at least we know the problem can be addressed!).</p><p>Let’s take the example of office suites; this is not one of those 1 1/2 times but still bears discussion. Office suites have typically been less of a UX problem for people because they bundle the must common applications computer workers need (mail, documents, spreadsheets, etc.). More importantly, the companies that produce them generally place a strong enough emphasis on consistency across the individual pieces that the cognitive load is minimal; they only differ in behavior where it makes sense based on what the tool does. They also tend to support good integration. For example, it’s easy to include a functioning spreadsheet as an “object” in a document, giving you live data to play with. There is enough similarity in what those tools do, though, that they really cannot be considered part of the 1 1/2 times “success story.”</p><p>The “half” success that I see is the operating system itself, specifically the windowing (GUI) system. It’s a success in that the mental model of a window and how you interact with it and what you can do with it is the same, regardless of the application you’re using. It’s consistent across the entirety of the user’s interaction with the machine. That sounds pretty basic, and it is, but that simple idea has done a great deal to make us more productive on our computers. Where it’s not a success is once you get into each application. They are all different. Each has (probably) a different set of authors. The closest it can come to interoperability among applications is the clipboard (but that’s pretty poor) or the file system (and that’s even worse).</p><p>The one true success I think we’ve managed, and this may make you laugh given the above, is the command line terminal. You heard me right. The world of *Nix systems is built on the idea of from hundreds to thousands of little programs that focus on one key ability each but with an understanding that they are part of a greater whole. With a few key concepts and this ability built in to most every program, I can chain together any number of them and end up with an amazing, flexible and functional data processing pipeline. But then, who really wants to <em>only</em> use a command line?</p><p>With this one solid success (and our half a success) in mind, is there any hope that we can provide better experiences to our users? Are there any lessons we can learn from the humble command line or the less-humble GUI? The good news is that I believe there is. In the next story, I’ll talk more about what I think we can take away from those successes and ways we can apply them to the things we build.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8afb96e811cd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Software is So Hard to Use?]]></title>
            <link>https://jskress-8494.medium.com/why-software-is-so-hard-to-use-7e0132ecf2a?source=rss-a1182d43be92------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e0132ecf2a</guid>
            <category><![CDATA[user-experience]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Stephen Kress]]></dc:creator>
            <pubDate>Thu, 24 Sep 2020 15:00:25 GMT</pubDate>
            <atom:updated>2020-09-24T15:00:25.253Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Person confused by software." src="https://cdn-images-1.medium.com/max/1024/1*hPo65E2qyXZv97dbHNTeww.jpeg" /><figcaption>Is this you?</figcaption></figure><p>Let me take you on a brief tour of how I think modern software based technology has failed us. In the early years (well, the 80’s when I first got started anyway), the clamor was all about the paperless office. Though that’s become truer than we actually hoped, it’s still not as true as the hype promised us. After that, the focus shifted away from paper and onto productivity, where it has largely stayed ever since. So, are we more productive than we were 30 years ago? Of course, the answer is both “yes” and “no.”</p><p>When I look around at the endless stream of software that’s supposed to be making my life easier, I see a mixed bag. Some tools are indispensable and act almost as a natural extension of me but many more are just noise and turn out to be less than helpful. As technologists and software developers, we have to ask ourselves why this is the case. Why are we, for the most part, failing at building tools that actually solve problems and are useful to the people we write for? It’s certainly not due to a lack of ability. When I compare the things I find helpful against similar tools that aren’t, the answer turns out to be pretty obvious. There are some traits that the better tools seem to share that the less helpful ones don’t have.</p><p>Fundamentally, the flaw is in ourselves. We are a “discrete” bunch, us software developers; i.e., we need things to be very specific to do our job. Software being what it is, it’s natural that we want things very precisely defined. But what’s the result? We create software that is very rigid, software that can come with a complex mental model because we’re trying to account for every case that could occur. When we do this, we (unknowingly?) put a huge burden on our end users to understand where <em>we</em> came from, how <em>we</em> think about the problem. What’s worse, we forget that any given tool is only a part of a broader toolset that the person at the keyboard/mouse makes use of. Since each tool comes with its own complexity, even the most accomplished user must deal with sometimes massive context switch overhead any time they need to change tools.</p><p>Let’s have a look at the area of process automation. All the offerings in that area basically fall into one of 3 types. The first is an enterprise platform that generally requires a team of IT professionals to install, configure and maintain said system. The costs are enormous; you either need your own development team or invest in a team of professional services folks to get what you want out of the thing. This means that only the largest companies can even think about taking advantage of the promise of automation. That means that likely 90% of the companies that might benefit from automation can’t, simply due to cost. That’s an inexcusable figure.</p><p>The second and third types are “no code”/“low code” solutions and RPAs (robotic process automation, if you weren’t sure). They claim to start with the premise that they are for non-developers. Yet the tools they provide are built the way a developer would approach automation and despite what we might like to believe, we don’t think the way most people do. At least, not about the software <em>we</em> write. (I am consistently amused at how often I run across developers who can’t understand why an end user has difficulty using the software they built and turn right around and complain about how unintuitive the tools they use are.)</p><p>Now, couple this with the fact that, more often than not, a full set of tools rarely has any cohesion across the individual tools. They are bad at, or outright can’t, talk to each other. People <strong><em>still</em></strong> have to enter data in multiple systems by hand, across these tools. Seriously??</p><p>All of this stems from the discreteness we build into our software and is exacerbated by those who need to provide sets of tools, often from disparate vendors. We end up building things that the end user has to take time to understand. And, since tools are almost always built in isolation, that understanding can only rarely be reused with other tools. Usually referred to as “cognitive load”, we heap this on our hapless users and then wonder why they don’t understand what we’ve provided for them.</p><p>What we should be doing is building software that acts as the end user expects. The best tools are those you don’t really pay attention to because they simply meet your expectations. You’ll notice that the companies that make an effort to create whole ecosystems for their software are generally far more successful at this sort of thing than those who don’t.</p><p>In the next story, I’m going to cover in more depth where our focus, as providers of software, ought to be if we’re truly interested in providing real help to people and begin to touch on practical things we can do.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e0132ecf2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>