[johndriscoll]

This seems like flaunting your budget more than improving your environment.

Maybe I just need to get my eyes checked again, but for some reason my code just doesn't perform any better or write itself any faster with more screen real estate and I'm as productive on my laptop as I am on my big screen.

4K is not for programmers, code is for programmers.

[chaz]

$500 is such a small amount to pay, it is easily recouped over the course of a year. $100k to pay a developer? Just 0.5% to break even through reduction in time spent, or increase in comfort, or decreased eye strain, additional time spent working, or improved retention. It can be a signal to potential hires that you spend money where it counts, instead of fancy foosball tables or a 75" plasma in the reception area. I always tried to get my team the hardware they wanted because it's such an easy problem to solve as a manager and can pay in spades.

I agree it's not an automatic improvement, but I'll take that bet every time.

[johndriscoll]

You seem like a very nice employer :)

For many of us that have in the past (or still do) work for less-than-very-nice employers, or ones without as much money available to spend on hardware for their team, there was/is always hope in improving your own practices. I have spent a lot of time investment improving my own practices and I wouldn't give up CLI, workspaces or dvorak for enough 4K monitors to line a conference room with.

[interpol_p]

I find I am much more productive at home (1x 30" monitor + laptop display) then I am at work (1x 24" 1080 monitor + laptop display).

The screen size absolutely makes a difference when you are working on a large project with lots of disparate pieces. When you jump between project-wide search, debugging, showing git diffs, and so on.

This is especially true if you do graphics work and code. When you need to move graphics assets around your filesystem and into your IDE it's nice to have the room (i.e., not so many overlapping windows) so you don't spend time digging for assets, resizing assets, running scripts over assets.

I consider myself very productive on just my laptop screen, but sometimes I postpone large architectural changes or heavy instruments based debugging sessions until I get home. There's less back-and-forth and a considerable speedup under certain workloads.

[johndriscoll]

I do all these things in a terminal. I used not to. But once I started doing things the CLI-way, I never looked back and have yet to discover a tool offering even half the productivity gained from keeping my fingers firmly planted on the home row. However, if you are locked into using an environment where doing the things you've said requires mousing or multiple windows with tons of resolution, then you have my sympathies.

[interpol_p]

While I do a lot on the terminal, not everything is faster there.

Jumping between symbols in your IDE is not going to happen faster on the command line because it's a spatial operation. You've located the symbol visually, clicking it to jump to definition is far faster than keyboard-navigating to it, or even typing it.

Merging is better with a dedicated merge tool than a command line merge. I have to resolve conflicts one to three times per day and I couldn't imagine a non-visual merge interface for complex files where manual edits from both sides are necessary. Being able to see it all at once helps.

There is nothing quite as good as Xcode's instruments on the command line — providing easy to navigate visual representations of your performance and memory use, graphs and other metrics. Having the instruments panel on a second screen is incredibly useful, the extra screen real estate is of real value here. Having to keep switching on a single laptop display is a pain in the ass.

Obviously there are many tasks that cannot be easily sped up on the terminal, saving slices out from Photoshop (when your designer hasn't done it properly). And then getting the resulting assets into your pipeline. This stuff is benefited by extra screen space.

But the main benefit is being able to see more code at once. And it is especially helpful in large re-factoring operations or with extensive debugging / performance profiling. As I said, it depends on the type of work. I can code just fine on my laptop but I tend to prefer coding focused features, or fixing isolated bugs.

I find the previously mentioned profiling and architectural changes are better suited to large screens where more code / graphs / visual assets can be seen at once.

You simply can't do "all these things" in a terminal. You can do a hell of a lot, but sometimes you need visuals and sometimes you need space. When you can see more code you don't have to hold as much in your working memory, your eyes can flick back and forth over your code and it makes it easier to see the dependencies and realise what you need to change.

[dllthomas]

"Jumping between symbols in your IDE is not going to happen faster on the command line because it's a spatial operation. You've located the symbol visually, clicking it to jump to definition is far faster than keyboard-navigating to it, or even typing it."

When the lab I worked in moved between buildings, we each broke down our work stations and set them up in the new spot. I went through a good week of getting work done before I noticed that I hadn't plugged in my mouse - I just never reached for it, because virtually everything happens with a thought when my hands are on the keyboard.

[interpol_p]

Most of the time when I'm coding I use the keyboard to jump to symbols. But when you are getting acquainted with a large codebase, reading through and clicking to jump to symbol can be a more efficient way to parse the code and understand its interdependencies.

It may depend on what you use to position the cursor as well — I haven't used anything but a trackpad in the last five years, and even on that mostly I use gestures to navigate UI. Since the trackpad is almost part of the keyboard it feels very seamless to scroll/tap and type.

[dllthomas]

Yeah, I'm much more likely to bump a trackpad than reach for a mouse, even when the mouse gives me much more control (I always find trackpads a little finicky), just because of the distance. My hands don't need to actually go anywhere.

Of course, I also bump the trackpad accidentally sometimes, but that's a separate issue...

[dllthomas]

"Merging is better with a dedicated merge tool than a command line merge. I have to resolve conflicts one to three times per day and I couldn't imagine a non-visual merge interface for complex files where manual edits from both sides are necessary. Being able to see it all at once helps."

Being able to see it all at once absolutely helps, but on a big enough console you can see it all just fine. Vimdiff is great. A large monitor definitely adds value there, GUI or TUI.

[interpol_p]

Fair enough, I normally use DiffMerge and find it fairly quick at pulling relevant sections from the files being merged. But I agree that the three pane preview is a must.

[shurcooL]

DiffMerge is my all-time favorite visual diff tool, with 2 fatal flaws that upset me so much...

1. Unable to edit text on the left side, only the right. >.<

2. Related to 1, unable to simply paste two pieces of text into two views and compare them, the way you could on www.quickdiff.com. You have to manually create 2 files each time.

So sad, because it is so good in all other ways! And it's not open source, so I can't step up and contribute. :(

[johndriscoll]

Although I don't have any problem stitching side-by-side commits in a terminal, or keeping multiple text buffers akimbo in general (its what the terminal is ideal for), I can't argue with most of your points because you're probably 100% correct in the context of your environment and it's limited modes of input (mouse-centric). And you have my sympathies. Being forced to use the mouse is a drag, and I would argue, a cruel thing to do to users from an accessibility standpoint. This (without going deeply into it) is what ultimately binds me to my "limited" set of inputs: keystroke. Yet being bound to the keyboard interface has only helped my productivity. When I get improperly formatted assets from my designer (i know, right?) I can actually do all manipulation, resizing, splitting, converting from the CLI faster than I can send ze an email! (even some minor visual stuff! but my designer fucking hates when i do that so i tend not to anymore.)

But your environment and my environment are likely completely different and YMMV.

[interpol_p]

As I said, it has more to do with your working memory than with speed or ease of navigation.

If you are viewing more code at once (which a larger screen allows you to do) then you can be more productive at certain tasks. I find that large architectural changes, performance profiling, and complex debugging are particular scenarios that lend themselves well to a large screen. This is the point I was making to which you replied with your preference for the command line on a small screen.

I am fully aware of how to manipulate image assets on the command line. Most computer vision and computer graphics tools I have written are executed via the command line so they can be pushed into my build phase. But I deal regularly with many formats from many tools, and not all of them can be dealt with easily on the command line.

The command line is not immediately better than everything — most visual oriented tools use keyboard shortcuts. You may not realise this, but committing those shortcuts to muscle memory makes using graphical applications just as fast, if not faster, than many tasks on the command line.

Do you also do all your performance profiling on the command line? Because that is a situation where visual data is very helpful, and a visual interface is in general more efficient and faster to navigate than the same on a command line.

As I said elsewhere, I do not use a mouse at all, so I do not have a mouse-centric workflow. I use the trackpad centimetres from my keyboard for gestures. This only requires slightly more physical motion than pressing a key, and ties itself just as strongly to muscle memory. I also use a graphics tablet for design, painting, and 3D modelling.

And to repeat, my initial point relating to large screens still stands. If you can see more code at once (whether on the command line or not, who cares?) then you do not need to commit as much to your working memory, and you can more productively make large scale changes that effect a lot of dependent code.

Same goes for performance profiling and debugging. The more info you can have up at once, the more you can dedicate your mind to reasoning about the problems at hand and the less you switch back-and-forth between views.

[johndriscoll]

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. I can only see one focal point at a time. But with enough time (and a trivial screen resolution) I feel that I can understand and improve on something as complex as the operating system running my computer, which is some very big software with parts of it (big and small) written in the early 80's on 80 character wide screens. This probably applies to everyone's operating system, so I'm just using it to juxtapose my next subject, which is the nightmare project (and I'm not making any of it up).

Looking back on the nightmare project almost makes me cry until I manage to suppress its memory. The difference between this project and my operating system is that my operating system is written by people who need to maintain software for a long time and, at some random point in the future, will need to rely on the maintainability of the code they wrote a lifetime ago. My nightmare project was not written with the project in mind, let alone the future of the project. Its problems were far removed from screen resolution. Its problem was the programmer. The programmer made it as painful as possible for me to understand what ze had written.

There was no abstraction and the code's entry point invoked every procedure the project directly in various loops. There was no difference represented between the software's big wheels and tiny gears. This made large scale changes difficult because dependent code had no typed contract, just access to buffers and primitives passed around in what was essentially a big main().

There was no cohesion of modules in the project and procedures just appeared together grouped seemingly at random and given names project1.x, project2.x, etc. Even if I had enough screen real estate to have the whole project's source open simultaneously, I would have been just as lost as when I was trying to wrap my head around a single file.

There was never a consideration for inversion of control and all the flow parameters were hard coded paths in giant conditional nests all throughout the project. That made simply guessing which code paths to analyze for a given input difficult.

Seeing more bad code doesn't make fixing it any easier and seeing more good code doesn't help me understand it any faster. When it comes to code, there are many factors influencing how productive I will be at working on it and screen resolution should be down there on the list, hopefully near the bottom.

"You may not realise this, but"

Was that necessary?

"committing those shortcuts to muscle memory makes using graphical applications just as fast, if not faster, than many tasks on the command line."

What's even better about the command line is that you can pipe input and output between applications. Chaining commands and remaining on the cli is faster for me than switching between applications and opening files. Most UIs have no way to define macros for commonly used procedures, whereas you can script anything cli-based.

"Do you also do all your performance profiling on the command line? Because that is a situation where visual data is very helpful, and a visual interface is in general more efficient and faster to navigate than the same on a command line."

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.

[nilkn]

I use two 27" monitors at work and would definitely feel a productivity hit if I were to go back to smaller or fewer monitors.

I dedicate one entire monitor just to a full-screen terminal with tmux running inside. It's trivial this way for me to edit and view and compare multiple files at once. I typically dedicate half of the second monitor to a browser, for testing, and the other half to administrative applications, like email, Jabber, and IRC.

The result is that the cost of context-switching is drastically reduced. I'm able to maintain focus for much longer stretches of time because I don't really have to ever completely switch contexts.

[Sir_Cmpwn]

A tiling window manager would blow your mind. Anyone whose productivity is improved by using tmux should really try out something like i3 or xmonad or awesomewm.

I use i3: http://i3wm.org/

My vim-like config: https://github.com/SirCmpwn/dotfiles/blob/master/i3/config

[BadassFractal]

I use xmonad on 2 screens, it's amazing how much better it feels than without a tiling manager.

[johndriscoll]

For me, just turning my attention (and my head) to a second monitor is too much. I greatly prefer multiple workspaces/virtual desktops to multiple screens. I'm fine with completely switching contexts when the cost of context switching is 0.

[nilkn]

I guess I can sort of understand this viewpoint, but I barely have to turn my head at all to go from looking at code to the browser. I can move my eyes between code and the browser (for instance) faster than I can switch between virtual desktops.

[maxk42]

Well said. I wrote code back on a 640x480 just as easily as I now write code on my 1080p. The only differences in productivity have come from me, as a programmer.

[catmanjan]

What sort of programming do you do?

Doing web development in VS2010+ feels very cramped on anything less than 2 1080p monitors for me.

[johndriscoll]

"What sort of programming do you do?"

Waddya got?

When I do web dev, I prefer a fullscreen terminal for editing and a virtual desktop with a fullscreen browser for proofing.

[crazygringo]

I've always felt the same. A huge monitor has never felt any better or more productive than my Macbook Air -- just bigger.

I mean, I just never need to be looking at more than one window at once. And when I need to interact with multiple windows (editor, browser, e-mail, docs, whatever), then I need to shift the focus to each of them anyways to reload the browser, change the code, highlight a new email, etc. -- so I always have to cmd+tab to the window no matter what.

After all, you can only look at a single window at a time, and I never need to keep things open for constant monitoring or anything.

(I do a little 'trick' with OSX, however, which is to always resize every application to use the full screen area, and keep it on its own desktop, so I never have to deal with the clutter and confusion of overlapping windows. And remember, dragging and dropping files etc. works between desktops just fine!)

[eloisant]

I like to have the following windows visible at the same time :

* Code editor * Terminal with the logs of my app * Web browser where I see my app running

It's really one task, and focus is on doing this one thing (coding). But having these windows visible at the same time really saves my short time memory.

[marmaduke]

I was thinking this as well and additionally praying I never work with code that requires debugging in 4K which may be inevitable if one is writing in 4K.