[interpol_p]

> To your repeated point: It's been my experience that better knowing what the code is doing leads to improving it. I am not a smart or clever person.

Here is the example I am dealing with right now. I have spent the last few months designing and implementing a complex system. It consists of hundreds of components and tens of thousands of lines of code. This project is reasonably small and I can keep most of the mental model "in my head" at once. So it's appropriate to edit on my laptop screen — or any screen. I can usually think of which symbol I need to jump to and within seconds I can be positioned in the editor, at that symbol.

Today I have had to take that component and push it into the rest of the system, which is hundreds of thousands of lines of code and it is a codebase that I have created over three years. I can't keep this all in my head, and this is where having a large screen produces noticeable productivity improvements and speed improvements to problem solving.

It is not a matter of not being able to jump around the code instantly from my keyboard — I can do that easily. It is knowing and remembering where to go and what I'm supposed to be working on. It is trying to maintain context while handling the many hundreds of errors that come about due to the necessary integration, API and architectural changes.

When I have a large screen I can afford to maintain a long list of files in a column on the left, I can see more large files at once. This allows me to constantly refresh my memory. I can glance at the data in front of me to determine what symbol I need to jump to next. I often mentally blank out when dealing with this level of scale — that "what was I about to edit?" feeling. When I am only on my laptop screen I have to start pulling up code, tracing a path back through it to redevelop context. When I have a large screen I can (usually) rebuild this context by glancing at the existing information.

(Note that this is not a messy project, I have spent a long time and given very careful thought to its design. It is just large and necessarily complex because of what it has to do. A bigger screen makes it faster to develop large scale interactions in such a project.)

> Was that necessary?

I'm sorry about that. It wasn't.

> What's even better about the command line is that you can pipe input and output between applications.

I have nothing against the command line — I use it all the time. I just like to take the most efficient path when working and sometimes that is not the command line. But that is tangential to the large screen point above.

> I do. I lack the sensory to monitor more than a couple metrics at once. I prefer profiling data that can be captured and analyzed later.

I had meant to ask if you analyse your profiling data on the command line. Do you?

[johndriscoll]

My operating system is a huge and complex beast. But a lot it, if not most of, is modularized in a way that extending it never requires my touching any of its source files. It assumes a mission statement to the user (I'll make one up and say it's "I will organize your computer's resources and let you use them easily") and code contracts that allow multiple components to serve this goal. Internally, the components are abstracted into statements of a very simple logic-flow.

This paradigm persists in many components themselves, from the bootloader to the end-user. When I want to update something in user space, it involves, from my perspective, no interaction with the operating system (even though it is really the one doing everything). Conversely if I want to do something as advanced as completely rewrite my filesystem implementation (something my operating system is very dependent on), I can, and without ever needing to touch my operating system's source. I could come up with any ridiculous way for a filesystem to work, and my operating system would be cool with it, and would operate the same way because if its modularized and abstracted design.

I would say these are incredibly good design features and that you would have to be extremely hard pressed to find a system that inherently cannot be designed in such a way as to mitigate maintainability and trivialize extensibility. Is your top-level project inherently so complex that adding smaller pieces requires that much screen real estate? If so, you have my sympathies.

> I had meant to ask if you analyse your profiling data on the command line. Do you?

Yes, my command-line editor has some powerful cvs support and manipulation features that make slicing the data up very easy.

[interpol_p]

My argument is that in some cases large displays make coding more efficient.

In particular when navigating a large codebase, rewriting or refactoring an existing design, and other similar tasks. Your argument sounds to me like "If I write perfect code, I will never need to touch old code again and thus do not need a large screen."

It doesn't matter how big or well designed something is. There are going to be cases where you need to revisit, redesign, or rewrite. Your suggestion that you should just write code perfectly the first time assumes you know the perfect design for the problem at hand — the perfect design is not obvious in many cases, not until your code is used in production and many features have been added on top of it do you begin to think that you can revisit it.

In my case, I am writing a graphics engine, code editor, parser/AST builder, documentation viewer, and project management system. As well as managing documentation and strings localised in 20 different languages.

I have re-written the code editor three times now, each time I have carefully considered the design and how I could proceed with a multi-threaded, efficient editor free from rendering bugs and able to handle large amounts of data. At this point I think I have a great design and implementation, but it is far from perfect. Much of it was developed on my plain old small laptop screen.

Recently I pulled all old networking code from the system and re-wrote it using newer and better high-level APIs that have since become available. This task was benefited by a larger screen because I could look at old and new implementation, while looking at a second new implementation from a different area of the code base as reference — while also still having room for API documentation and related files. It just made things faster, it would still be possible on a small screen.

When I profile the OpenGL graphics engine being able to correlate performance graphs with locations in the code, while displaying GPU buffer contents is something that would feel quite clunky on the command line. It's also faster to be able to glance at this data with my eyes without having to flip between windows / contexts.

So my top level project is complex, but I never claimed it required much screen real estate. It can be more comfortable and faster to perform certain tasks with a large screen — which reduces the need for mental context switching. That's what I'm arguing and I find it hard to understand why you are arguing against this point.

> If so, you have my sympathies.

Your attitude seems quite condescending. As if my code is poorly designed and unmaintainable. This is not the case.

As I said: coding does not require extra screen real estate. It can just be more comfortable and more efficient when you have it.