1.  

    I do.

    In all the time I’ve been using git (I was an earlyish adopter, mercurial user prior), however, I consistently get teammates approach me to ask about code before looking at git blame. Most people review PRs by looking at the entire diff too.

    So lately I ask myself if it’s worth the effort.

    1.  

      I’m in the same boat at my current job. I have a small team of junior devs, and the practices they’ve learned from bootcamps and stuff, particularly in git, can be a be demotivating.

      I generally now just look at diffs. But, I do appreciate articles like these, and I definitely try to reinforce better habits.

      1.  

        Most people review PRs by looking at the entire diff too.

        Are you suggesting not looking at the entire diff? Or just not only the diff?

        1. 6

          I review each commit in sequence.

          Assuming the commits are written well, this is much faster as I’m reviewing related changes together.

          When people put unrelated changes into the same commit, or related changes into different commits, I have to change mental contexts whilst reviewing, which takes away energy/effort from doing a good job of the review.

          1.  

            I meant any care given to having the commits reflect my intentions is lost. It’s as if I’d pre-squashed all the commits.

            1.  

              There’s still later, when you need to revert part of the work, and it’s easy because it was a single commit…

              1.  

                That’s a big limitation of git. It should be much easier to back out a whole series of commits.

                The typical git way to do this is to merge with ancestor so you can just back out the merge commit itself. Still not quite the same thing as undoing a merge, but close enough.

                1.  

                  I actually meant the other way around - I’ve made 10 sensible, self-contained commits and only have to revert one to fix an issue.

                  That means that I get to keep the rest of the functionality I built running while I rollback one change.

                  If your change history is a spatter of half-commits and unrelated changes are rolled together, you have to manually pick apart the bits you want to rollback (or just reset to a known good state).

                  Even if a reviewer isn’t using the commit log, the operations team and future maintainers are.

        1. 2

          This is why npm packages need some form of namespacing; something like username/package-name This would prevent package name squatting or situations like this where the dev hands over maintainership of the package to someone else.

          1. 1

            Using URLs directly would help with this too.

          1. 2

            Package managers are a rug over dirt.

            I honestly wish we added our dependencies directly to our git trees. Updating a package should look like a source diff, your team should review it. I’d want tooling to automate the download, and maybe de-duplicate shared transitive dependencies, but that’s it! git commit is your package-lock.json.

            Note that I’m not talking about auditing every single line of code: even a cursory review would reveal things like one of your dependencies being massive and having a huge attack surface, etc. It’s about surfacing costs so the incentives are better aligned.

            1. 5

              Sounds like decent stuff but I do find it amusing that some really basic things are getting big headlines: “Notepad Supports Linux Line Endings” and “Copy/Paste Arrives for Linux/WSL Consoles”.

              I’m hoping the console improvements are actually useful since the worst part about the WSL (aside from I/O performance) are the really poor consoles in Windows, including current 3rd party offerings.

              1. 2

                I actually did get excited about a couple of those. Which I guess just illustrates how low the bar was to begin with!

                1. 1

                  including current 3rd party offerings

                  ConEmu is pretty good. The only problem I’ve noticed is that it likes to put the cursor one line above (than the actual prompt line) in my zsh prompt :D

                  1. 3

                    ConEmu is an ok console, but it’s a poor Terminal Emulator, in my experience. (In part due to lag and some minor issues when processing VT-100 codes).

                    If you don’t use Vim or co, it seems to do quite servicably

                    1. 1

                      I used it for neovim in tmux, haven’t noticed any problems (though it’s not very fast indeed)

                    2. 1

                      UPD: another issue: in ConEmu, paste doesn’t work inside tmux. Switched to wsltty (mintty) :)

                    3. 1

                      The user, of course doesn’t (shouldn’t) care about how hard something was to implement, but the people writing these release notes are biased by that sometimes, it’s only normal. The LF change must’ve been a ton of work. Most of it probably not coding, but still work.

                      I don’t know it for a fact, it’s just speculation based on experience. By the way, I work at Microsoft though nowhere near notepad.exe.

                      1. 1

                        Yup. it’s amusing, but sadly it’s a Thing. I adopted WSL here at work because for some kinds of access it’s Windows or the hiighway and WSL is a LOT better than being stuck in CMD.EXE/ Powershell.

                        Thing is the cut&past experience at least before these changes was AWFUL. I’m embarrassed to admit that our workflow involves a LOT of cut&paste, and the experience was abysmal.

                        1. 1

                          The Notepad update was quite interesting considering it took 33 years for that basic feature to finally be there. No more opening config files and seeing nothing but a very long single line.

                        1. 4

                          It’s interesting that they didn’t explicitly prohibit ICE itself, only collaborators.

                          Also, this change definitely infringes on the other lerna contributors’ copyrights, despite the explanations given by the original author. The should have used a contributors license agreement. I wish Github had better tools/policies regarding licensing and CLAs.

                          1. 8

                            They do ban “Microsoft Corporation” and its subsidiaries. Doesn’t that include Github!?

                            1. 4

                              It does, so Lerna is not available to GitHub under MIT license. GitHub is still okay, because GitHub is granted a license to publish under GitHub Terms of Service D.4. As I understand, GitHub can publish Lerna, but can’t use it.

                              1. 1

                                IANAL, but the purchase is not finalized yet.

                                (I work for Microsoft)

                                1. 1

                                  The state of the purchase doesn’t really change anything here.

                              2. 7

                                this change definitely infringes on the other lerna contributors’ copyrights

                                Everyone’s contributions (and the whole project right before the license switch) are still available under MIT. MIT permits sublicensing. I guess they should’ve kept the old license in the repo and mentioned what it applies to… but there’s no actual requirement that “old git revisions don’t count as included with the Software” :)

                                CLAs are terrible and unnecessary.

                                1. 3

                                  From the title, I first thought this might be an article from a long, long, time ago. Nah, some vulnerabilities just persist. I left Windows long time ago. Have there been any improvements on preventing or detecting these risks?

                                  1. 1

                                    Granted I’m a bit biased, but what’s the risk? I’m missing it.

                                    1. 3

                                      In principle, malware could hide in it - and probably does, but I don’t think many people are under the illusion that they can detect malware without specialized tools anyway. The most “practical” use I can think of for it is data exfiltration. I think most of the risks are around bugs rather than malicious use; it’s a somewhat bizarre feature, and not well-known, and as such it should be regarded as technical debt.

                                      1. 4

                                        I see. I’m sure it’s used by Windows though.

                                        It’s a pretty common feature across many filesystems: https://en.wikipedia.org/wiki/Extended_file_attributes#Implementations

                                        1. 3

                                          Yes, you’re certainly correct that it’s not that rare a thing. As the original article notes, NTFS added it for parity with Apple’s HFS+. That doesn’t really change that it’s obscure and fragile, but certainly Windows shouldn’t bear the blame alone.

                                        2. 2

                                          You nailed it! Hiding malware and storage channel for exfiltration are main issues.

                                    1. 4

                                      It’s a bit more nuanced than that. Sean was referring to most of the UI: https://www.reddit.com/r/javascript/comments/8qpwi7/office_365_ms_teams_skype_code_and_the_edge_debug/e0llhzp/

                                      (I don’t work for any of the mentioned teams, but I do work at Microsoft).

                                      1. 1

                                        This should probably be the link instead…

                                      1. 1

                                        The Spanish in the screenshot reads quite mechanical…

                                        1. 3

                                          Re: “the medium matters”

                                          I’ve always wondered how the existence of IDEs with their helpful features affected the evolution of Java’s syntax and standard library.

                                          1. 1

                                            I know that C#’s LINQ syntax put “from ” first because it made intellisense easier in Visual Studio, related?

                                          1. 4

                                            The two main reasons I can’t use nvi are lack of ‘expandtab’ (which in languages where the convention is to indent with a certain number of spaces is very annoying), and the lack of a way to set options based on filetype. All I really need is some command that matches on pathnames like:

                                            setfor *.rb et ts=2 sw=2
                                            

                                            Maybe I could achieve something similar with a wrapper script, I’m not sure. But even then, the lack of ‘expandtab’ is a deal breaker for me.

                                            1. 2

                                              In acme, I use hard tabs for everything and git filters to convert to spaces.

                                              It’s not free of quirks. Works well most of the time.

                                            1. 24

                                              Bring back IRC I say

                                              No need to bring it back, it’s always been there. The problem is convincing everyone else to use it.

                                              1. 33

                                                IRC has a fair share of problems which are often circumvented by layering additional services like bouncers on top of it. I like it for its ubiquity, but let’s not pretend it doesn’t show age everywhere.

                                                1. 19

                                                  I think matrix could very well be the successor to IRC. Open, federated, secure, multi-device sync and good support for bridges to other protocols.

                                                  1. 13

                                                    I can’t bring myself to like a communications protocol that’s based on HTTP+JSON, with the reference client written as an Electron app. It just all feels so… inefficient :(

                                                    1. 4

                                                      The very core of matrix is just the graph behind it all. JSON is just one representation of the information and HTTP is just one transport. Those are the only reference implementations right now, but others are possible, if I’ve understood correctly. But someone more knowledgeable should probably weigh in.

                                                      1. 2

                                                        Those are the only reference implementations right now

                                                        The problem with reference implementations is that, by inertia, they end up being the only implementation.

                                                        1. 1

                                                          Would you rather there wasn’t an implementation? But, in this case, there are several other implementations. There’s the next generation reference home server dendrite (in golang instead of python like synapse) and ruma (in rust). And there are lots of clients. I think only riot supports e2e crypto, but I hope others will start supporting it as it stabilises.

                                                      2. 4

                                                        To be fair, Riot can run perfectly happy standalone. In fact, I have it running right now on my OpenBSD box. Also, there are many other clients!

                                                        1. 5

                                                          HTTP+JSON isn’t all that inefficient, just a bit of extra headers, whatever.

                                                          Matrix is actually fundamentally inefficient in a different way — it’s not ephemeral message passing like IRC or XMPP, it’s a replicated database — and it’s worth it.

                                                        2. 6

                                                          I stopped using IRC and my bouncer 2 weeks ago for Matrix/Riot on my own server with my own IRC bridges and couldn’t be more pleased. Works incredibly well.

                                                          edit: was an irssi+irssi-proxy user for over 15 years. Tried every other bouncer. Hated them all. Had a perl script to send my phone a pushover notification for mentions. It worked, but it sucked trying to open up IRC app and find the conversation with no scrollback and respond.

                                                          Now I have: consistent chat client on every device, always have scrollback, all my logs are stored in Postgres, logs are searchable in every client and the search is handled server-side, and I can do E2E encryption with my friends on Matrix. I will never experience Slack bloat because the federation means I only need one server connection and account.

                                                          1. 4

                                                            The Riot web app can also serve as a nice IRC client (+bouncer, email notification, etc) if you only need the networks they bridge to.

                                                            1. 3

                                                              I haven’t been impressed with the quality of tooling or clients yet. Their Debian package documentation is incorrect and commands tell you to… run the same command you just ran. I haven’t seen a client I’ve been terribly impressed by either; Riot is your typical Electron fare.

                                                              1. 3

                                                                Riot is your typical Electron fare

                                                                The electron wrapper is completely optional, why do so many people say such things, that’s unfair :( I just use it as a pinned tab in Firefox.

                                                                1. 3

                                                                  Even without the performance concerns of Electron or running in the browser, there’s still the fact these overgrown web apps feel alien in UX on every platform.

                                                                  1. 2

                                                                    I’ve found it to be very unperformant and laggy.

                                                                2. 1

                                                                  Didn’t know about this. Thanks for the tip.

                                                                3. 10

                                                                  The IRCv3 working group is attempting to standardise a lot of interesting extensions to the old IRC protocol in a backwards-compatible manner. Amongst other things, they seem to be working on history, standardised registration/authentication, and metadata such as user avatars.

                                                                  1. 2

                                                                    One aspect of Slack I’d be interested to hear any progress on is the fact that it combines chat and fileshare for groups.

                                                                  2. 1

                                                                    Is Twitch still running this way?

                                                                  3. 5

                                                                    Maybe if it was written in JavaScript, used a million npm packages, invented some new Json/Jose derived protocol,.. then you might have a hope.

                                                                    In all seriousness, I ask myself that question all along. At work we use lync and skype for business and those still feel like a step backwards compared to old Skype, man, icq, and irc. In fact we had logging turned on for a while but the fat xml logs are up our entire email box so it was turned off company wide.

                                                                    1. 5

                                                                      Additionally, Slack supports IRC. I just use tmux + issi to connect to Slack and other IRC networks.

                                                                      1. 6

                                                                        Slack’s gateway is highly lossy though.

                                                                        1. 2

                                                                          What do you mean? I haven’t had a single issue.

                                                                          1. 12

                                                                            You lose formatting, inline replies (so you will see out of context messages), that kind of thing.

                                                                            1. 1

                                                                              Ah, gotcha. Thanks for the clarification.

                                                                    1. 9

                                                                      But could even a 1980s cell phone have been made in 1946? That’s decades before ICs. A year before the transistor even. Maybe the trunk sized device they’re talking about? Not sure if that qualifies as what most people consider “cellphone” or if it would have been so widely accessible to say “we” could have one.

                                                                      1. 2

                                                                        They may have started out even more primitively than they did in the 80’s but they would have evolved fast. It’s barely been 40 years since they hit the market and they’ve evolved into completely different beasts already so I’d expect that by the 80’s they’d have done so too.

                                                                        1. 2

                                                                          I think at best we could have progressed into decent phones 5 or 10 years earlier (So late 80s maybe instead of 1995?), I doubt it would have been a constant progression though, I don’t think we would be using an equivalent of 2022-2027 phones right now.

                                                                          1. 6

                                                                            Though we seemed to get good phones and then just shoot straight past them.

                                                                            Was nice having a battery life measured in days if not weeks rather than hours.

                                                                            1. 2

                                                                              I wonder how well this comment will age, re:2027 phones ?

                                                                              1. 1

                                                                                “My holographic VR phone’s battery lasts just 20 minutes when I’m away from microwave power!” :(

                                                                        1. 3

                                                                          There’s a shell injection attack in there, isn’t it?

                                                                          https://github.com/tjgillies/unix-web/blob/master/src/server.cr#L7-L10

                                                                          1. 6

                                                                            Technology management seems to be a bargain bin for management ideas (and managers) that failed elsewhere. Just as doctors are highly intelligent but the favorite targets of financial scammers (rich, overconfident, financially clueless due to lifetime residence in educational/hospital meritocracies) the technology industry seems to be a preferred destination for those peddling bad management ideas. Everywhere else, Jack Welch style rank-and-yank has been agreed to be counterproductive. Not in tech. In software, it lives on.

                                                                            Scrum is Taylor’s so-called “scientific management”, which worked poorly in factories and is a disaster in software.

                                                                            I saw a company kill itself with Scrum. Scrum set off a talent bleed in software that couldn’t be stopped. Core business functions suffered because of the software attrition. It was bought for less than 10% of its previous valuation. Stories like this are common.

                                                                            1. 2

                                                                              Everywhere else, Jack Welch style rank-and-yank has been agreed to be counterproductive.

                                                                              Scrum is Taylor’s so-called “scientific management”, which worked poorly in factors and is a disaster in software.

                                                                              What are your favorite texts on those two points? I’m interested.

                                                                              1. 2

                                                                                I saw a company kill itself with Scrum. Scrum set off a talent bleed in software that couldn’t be stopped. Core business functions suffered because of the software attrition. It was bought for less than 10% of its previous valuation. Stories like this are common.

                                                                                On the other hand, every badly implemented management switch can kill companies quickly and lead to bleed. What in this case was scrum-specific?

                                                                                I’ve seen companies break on scrum and some thrive on it. (the latter ones always being ones that were un-dogmatic and seriously weighting time/gain)

                                                                              1. 2

                                                                                Actually, let’s just stop making estimates.

                                                                                There are counterexamples to what I’m saying. If you’re launching something into space and it’s going to cost millions of dollars to bump that launch from May 19 to May 20, then you need adult project management and you need to be 3-10x over capacity. Only government-funded research can afford this, but it’s what you need when you have deadlines with severe consequences if they’re missed. I don’t mean “An executive is mildly embarrassed in a way that no one will remember next week”, but “Millions of dollars are lost or people die”. Then, you need adult project management– not this Agile shit.

                                                                                In the corporate world, estimates are purely about manipulation. It’s to create internal competition. The people who underbid in estimation get their first pick of projects. Engineers suffer, and executives gain, due to the winner’s curse. It’s a way for management to push people to work unreasonable hours without explicitly asking them. Then they can say, “No one is making you work weekends, but you committed.” It’s a trap.

                                                                                1. 5

                                                                                  If someone asks you for an estimate which they’ll in turn use to try and plan other dependent work, they should be open to (even welcome!) being told as soon as possible if the estimate is going to change in either direction.

                                                                                  When used that way, as a communication mechanism, they’re useful. But it requires a company wide belief that their purpose is estimation.

                                                                                  Keep people in the loop at every turn. The next time you’re told you committed, you remind them that you estimated.

                                                                                  Don’t get trapped :)

                                                                                1. 7

                                                                                  Github now has a “squash and merge” option on pull requests, so you can have it both ways: a clean master branch history and a messy PR commit history. Only problem is that your PR branch commits no longer cleanly map back onto master so git branch -d always complains, etc.

                                                                                  1. 7

                                                                                    I’ve never understood when I would want to use squash and merge because it completely botches the commit message by just stitching all of the commit messages from the PR into one. That’s typically not what I want, especially if the PR commits are messily organized. It then becomes the responsibility of the person merging to write the commit message, which may not be the same person that submitted the PR. And you have to write the commit message in the Github web UI.

                                                                                    I do use the “rebase and merge” functionality though.

                                                                                    1. 3

                                                                                      It then becomes the responsibility of the person merging to write the commit message, which may not be the same person that submitted the PR.

                                                                                      Yeah, I think this is only a good idea for teams where the author of the PR is also the one merging it, and they just use the PR for review and comments.

                                                                                    2. 3

                                                                                      I’ve been very happy since this feature came out: I used to waste time crafting a commit timeline that communicated intent… now I just commit as I go, make sure no PR is too big, and then squash and merge (finally crafting a decent commit message at the end).

                                                                                      1. 8

                                                                                        I have real trouble with syntax highlighting. It makes everything unreadable to me. I can’t read most websites that display code because of the highlighting. Of course, acme, my text editor, lacks any syntax highlighting.

                                                                                        It’s interesting that I didn’t start like this. Before I discovered Plan 9, I used highlighting (usually) just like everyone else. I didn’t turn it on, but it was usually on by default in the vim configuration shipped by Linux and off by default in BSD’s nvi (or simply lacking the original vi shipped in Solaris). But if it wasn’t on already, I didn’t bother turning it on.

                                                                                        Now after I stopped using syntax highlighting for many years (close to a decade now), I simply can’t read code with highlighting on. If some colleague wants some help with some code, my first request is to turn nightclub mode off.

                                                                                        Oh yeah, I program using a proportional font too (Lucida Grande, 14 point): http://i.imgur.com/XovEU4g.jpg

                                                                                        1. 3

                                                                                          Project Fortress (a programming language research project) proposed mathematical syntax for programming:

                                                                                          Mathematical syntax The idea of “typesetting” the code using LaTeX has received mixed reviews, and many potential users find the issue of keyboarding the extended Unicode character set daunting. Nevertheless, even in its more verbose ASCII form, the syntax of Fortress, especially the notion of treating juxtaposition as a user-definable operation, has proved to be very convenient.

                                                                                          I have used unicode greek characters in my code, which I find very helpful, especially when doing scientific programming. My colleagues didn’t like that however and the toolchain was complaining too.

                                                                                          1. 3

                                                                                            I think that this might be unpopular and it’s certainly a bit bold, but I often thing that becoming a programmer rather than a mathematician has a lot to do with mathematical notation.

                                                                                            Also I want to point out that there is APL and that despite of my previous statement I’ve seen impressive things done with it.

                                                                                            1. 5

                                                                                              Ken Perlin wrote a small post arguing that one approach is more procedural, while another is declarative (setting up a state of the world and shifting the world while preserving correctness).

                                                                                              As for APL, I wrote k professionally for about a year, and am happy to talk about that experience.

                                                                                              1. 2

                                                                                                I’d be interested in hearing about professional k usage!

                                                                                                1. 2

                                                                                                  Me too!

                                                                                                  1. 5

                                                                                                    It’s been a while, but here are a few observations about k:

                                                                                                    • While initially it looks like gibberish, your mind starts picking apart common patterns as “words” and will eventually parse things at a higher level.
                                                                                                    • The claims of “flawless code” with respect to the interpreter is basically true. It’s very tightly written, fast, and exact. It doesn’t use a lot of “tricks” like JIT compilation, it’s just solid hand-written code. The only trick that comes to mind is it tracks whether an array is sorted or not, so accidentally doing two sorts doesn’t hurt you.
                                                                                                    • Much like lisp forces you to think in recursion, k forces you to think in terms of matrix operations. Instead of doing a depth-first search, you might generate a cartesian product of all possibilities and filter out the wrong answers. Inefficient from a Big O perspective, but the filter loop doesn’t have a lot of pipeline hazards so the result can often be faster. This is probably the biggest key to k’s speed, although I’ve seen claims that the interpreter can fit inside a typical L1 instruction cache which would help as well.
                                                                                                    • k programmers really hate loops.
                                                                                                    • APL (and by extension k) has the best array index and traversal primitives of any programming language, period. You can slice up and down columns, rows, and (from what I recall) any dimension from a multidimensional array. You can also construct new arrays from an array of indices, much like [x[i] for i in indices] would do in python. The only language I’ve seen that comes close to this power is MATLAB. LINQ might be able to do this as well, but almost certainly in a heavier manner.
                                                                                                    • The k sort operation doesn’t actually sort lists. Instead, it gives you the indices of the list in sorted order. You can immediately use the array indexing to give you the sorted list, or you can use the indices for other operations. This is useful to sort a list by a ‘key’ instead of the raw data, or to sort a list and keep other lists in sync with it.
                                                                                                    • k programmers are obsessed with code golf. This isn’t as pointless as it seems. As someone pointed out to me, most of the operators in k are roughly in the same order of magnitude with respect to execution time. Since k operators are usually one or two characters, a shorter program usually is faster!
                                                                                                    • k is great when you stay inside the ecosystem. Where you have trouble is getting in and out of the ecosystem. At the time when I was working with k it had a terrible command-line UI, hard-to-debug foreign function interface, and you had to work a lot to have fault-tolerant data processing. There also wasn’t a robust OSS library community, so you basically had to do everything from scratch. This may have improved in the past few years!
                                                                                                    • A great example of “great when you stay inside the ecosystem, terrible crossing that boundary” is k’s date format. Timestamps in k are stored as seconds since an epoch. Great! Except Arthur Whitney wanted to maximize the amount of useful time expressed by the datatype, so the epoch is January 1st, 2035. This means time is currently negative, and you have to do all kinds of annoying translation to compare to unix time. Looks like kdb+/q uses 2001-01-01 instead, likely to make mental math a bit easier.
                                                                                          2. 1

                                                                                            That was really insightful. Thank you!

                                                                                            I am not an acme user, but I considered trying it. What I always wondered about with those self-made commands. Are there like collections of them? I know they aren’t hard to make, but I think a collection could give you ideas, starting points, etc., kind of like a vim plugin or config. Even if I don’t go with huge packages usually (be it vim or zsh), I kind of like ideas that you find while looking at existing stuff.

                                                                                            Or is that generally discouraged for some reason and never fell important?

                                                                                            1. 6

                                                                                              Acme users (all 10 of us) write their own commands when they need them. I don’t know of any collection of commands, sorry, what would be the point? Every environment is different. The philosophy behind acme (plus plumber) is that it’s an integrating environment of arbitrary Unix software (I’m counting Plan 9 as a Unix here), not an integrated environment. It makes it really easy to integrate any reasonably written Unix tool into your workflow, but it doesn’t really provide any such built-in integration by default.

                                                                                              You don’t need any collection of commands to use start using acme though. Usually on every new project I start with a blank environment. I add stuff to it only as needs become apparent.

                                                                                              1. 1

                                                                                                Okay, this is what I expected. I just wondered whether my assumption was correct that people do it that way. Also wondered if there are some scripts, not so much for reuse, but as example, so “smart tricks” on how to do something in a simple way, because I like to read code. :)

                                                                                                Thank you!

                                                                                              2. 1

                                                                                                It’s pretty common to have a+ and a- for increasing/decreasing indentation, and c+ and c- for commenting/uncommenting. Beyond that I’m not aware of any conventions.

                                                                                                1. 1

                                                                                                  I have obtained some of mine from other people. Someone on a different lobste.rs thread shared Clear with me (to wipe a terminal).

                                                                                                  1. 1

                                                                                                    Edit ,d will clear a window (including a terminal).

                                                                                                    1. 1

                                                                                                      That’s what I used to do, but Clear is easier to middle click, and it keeps my prompt.

                                                                                                2. 1

                                                                                                  Holy tag batman! ;)