1.  

    Attempting to organize 10 years worth of references into a BibTeX database. It’s a project, that’s for sure.

    1. 6

      xfontsel was never cool. It was necessary, thanks to that ridiculous font specification system, but it was never something you put on the desktop to show off.

      1. 9

        Working on my book proposal after spending some time this week gauging how much work it will be to find relevant materials. I also have a wedding party to attend, and another party for a friend who just moved back to Canada from the UK. He was happy to get out before Brexit turns into an even bigger dumpster fire.

        1. 2

          I think I made a comment like this before, but working on a book seems like a nice project! I suppose the proposal is meant to pitch the book to a publisher?

          1. 3

            Even if you don’t pitch to a publisher (something I’ll probably do) writing a proposal is recommended so that you can focus your effort better.

        1. 9

          I’m a mess! Pretty tired (training and working a lot, and sleeping badly), but I also want to do so many things while having no time.

          On friday evening and saturday: Participating in a running competition (I am running 150 and 300m), going to a party, picking up a new contact lenses, picking up my racing bicycle which is repaired, athletics training. I also want to write an article about the conjugate gradient method, build a minimal Linux live CD (see this submission) and try if I can make an install script (probably based on arch linux installation guide). I also have two running projects of making a nixie clock and making a path tracer. But I also have to a lot of chores on sunday (groceries, cleaning, washing), and my GF is coming over…

          I don’t understand how people get to do any coding while working full-time :(

          1. 21

            I don’t understand how people get to do any coding while working full-time

            A lot of us don’t.

            1. 3

              I code outside of work for maybe 20 hours a year, burst over a few weekends. It’s not much.

              1. 3

                Yeah, it’s just not a thing I get to do much any more, between work that is non-coding, and home, where there are two little people who demand basically all of my time and energy. I am idly kicking around the idea of building a basic iTunes replacement (because word on the street is that the new “Music” app will no longer support my use-cases), as a way to get back into Apple platform development; but realistically, coding time will likely be supplanted by “sitting on the sofa with a glass of wine decompressing time” until the girls are less demanding.

                1. 2

                  Swinsian might be able to replace iTunes for you. I certainly don’t mean to discourage you from scratching your own itch, though; that’s bound to be more fun and rewarding :-)

              2. 7

                I don’t understand how people get to do any coding while working full-time :(

                Slowly. And with a massive TODO file.

                1. 6

                  I don’t understand how people get to do any coding while working full-time :(

                  There’s a reason why I rarely code for the FOSS projects I’m involved in as a hobbyist. I just can’t code for 8 hours and then 2 more at a reliable pace. I can be helpful, answer questions and triage, though.

                  1. 3

                    making a nixie clock

                    That’s a very fun project! How much are you building yourself? If you are buying most of the parts it’s definitely the type of thing you can knock out in an afternoon after work.

                    1. 3

                      I’ve bought the actual nixie tubes, but I still have to buy the driver parts. I’m mostly following EEVblog’s approach, but I don’t want to have a wifi-connected thing, so I’ll probably buy a high-accuracy RTC chip or breakout board.

                      I have no experience with high-voltage stuff, so I’ll probably just buy a boost converter module that boosts the voltage enough (though it would be fun to design a switch-mode boost converter myself… and I still might decide to go down that rabbithole). Then I still have to design the PCB itself, and get it manufactured. So I’m thinking more in terms of months than in terms of afternoons ;)

                      If you made one and have some tips for me, I’d be happy to hear them!

                      1. 2

                        I ended up following something pretty close to https://www.instructables.com/id/Arduino-Nixie-Clock-for-Absolute-Beginners/ And I just didn’t go through with the last step of soldering it all down. This was pretty early into my EE tinkering phase so I tried not to overcomplicate it.

                        The engineering of it can be made pretty simple so I’m not sure I have any tips on that front, but if you want to show it off I’d put some extra time into thinking about your casing. I got much better feedback on mine once I put it in a 3D printed box to hide the components.

                    2. 3

                      path tracer

                      Ooh! What for?

                      I don’t understand how people get to do any coding while working full-time

                      Magic. For me, I see it as I’m either learning something new I can then use for work, or working on something that’s different enough that it doesn’t feel like work.

                      Hence HW projects.

                      1. 1

                        It’s cliched but you’ve got to make the time (and you’ve got to want to do that, and fair enough if you don’t!). I like to go to a cafe for breakfast on at least one day each weekend, take the laptop, and tap out a bit of code. I don’t get a lot done, but it’s more than nothing, and it adds up.

                      1. 6

                        Starting work on a book. I’ve decided I’m going to write about the history of debugging and how it ties into development practices. I expect this will take me a while, but I’ve had so much fun working on the essays that I want to explore this further. I took the next week off to try and come up with a decent proposal.

                        1. 2

                          My favourite “ping” moment occurred when I was working on an embedded media device that supported DLNA. Our team wasn’t about to write a DLNA library so the company licensed one. We put it to use and it mostly worked, although there was lots of fiddling.

                          Once we got the device going we noticed that, after a while, the device would just “get stuck”. Things that were running would work, but nothing new could be spawned. We managed to recreate the situation on a device that we had a shell on and lo and behold, the process table was full… of pings. Lots and lots of pings.

                          It didn’t take long to figure out that it was the DLNA library. Turns out that to implement some form of network checking or keep alive (I don’t know since I didn’t work with DLNA all that much), the DLNA library would basically run system("ping -c 1") on a regular basis. And yes, I’m pretty sure it used system. Each thread created in the DLNA library would do this, so the longer the device ran and the more you did with it, the worse it got.

                          Eventually we corrected it (I don’t remember the resolution since I wasn’t involved), but it was a pain since we had to get the source code.

                          1. 8

                            I’m not sure if it’s appropriate to talk about CGI like it’s dead. OpenBSD ships slowcgi(8) and their man page viewer in mandoc is a genuine CGI application. The BCHS people endorse pure CGI with C, too.

                            (Whether these are good ideas is another story, but they exist right now.)

                            1. 5

                              I use them for a couple things (the order form on https://atreus.technomancy.us being one of them), and they’re fantastically useful for sites like that which can be 99% static. I wish more people realized that not everything has to be full of moving parts everywhere.

                              1. 3

                                Whenever I have some sort of local web thing, I still use CGI. It’s easy and, like you say, works well when the site is mostly static. Adding all that other stuff seems like a complete waste.

                              2. 4

                                Author does write

                                CGI scripting was undoubtedly useful and continues to be useful for small scale web applications, such as developer utilities, simple form data collection and local intranet tools.

                                (my emphasis)

                                1. 1

                                  Oh, I see. My bad. I skimmed the article too quickly.

                                2. 2

                                  In the first draft of this article, I used the term “near obsolescence” rather than just the term “obsolescence”, because you’re right, there are still people out there using CGI scripts (I am one of them).

                                  Ultimately, I removed the weakening word. Determining when a technology is obsolete is a tough call, and often opinion based. In this case, it’s my opinion. If the definition of obsolete is “no longer produced or used; out of date.”, then there are very few technologies that can truly and in all cases be described as obsolete. In the case of CGI scripts as they were used in the late 90’s, I think it’s safe to say that that train left the station a long time ago.

                                  1. 4

                                    First I thought no one needs this article, but then I realized I’m now old. ;)

                                    By the way, why your website keeps making requests to https://rickcarlino.com/owa/blank.php ?

                                    1. 1

                                      I realized I’m now old

                                      Same.

                                      making requests to https://rickcarlino.com/owa/blank.php

                                      Open Web Analytics

                                      1. 2

                                        It sounds like a rather intrusive approach, and for people on mobile, it’s not free of charge either.

                                1. 5

                                  This is a decent essay with a few good points that I mostly don’t believe. The (self-admitted weak) case put forth by the author about what could offer great productivity gains are not compelling because people do use those things and continue to have similar problems. Yes, the web has made information a lot easier to get. At the same time, we’re doing a lot more. It’s not just apps being shipped, it’s apps on huge, distributed infrastructures being used by a lot more people.

                                  I did like the notion that accidental complexity is much more prevalent than originally thought. I think there’s a decent case there.

                                  One thing that irks me is the insinuation that things like automated testing and garbage collection are new developments. The authors says that there have “been other improvements in software development since 1986”, then goes on to list distributed version control, garbage collection, and “Agile” as new-ish things. Automated testing has been around since the 1960s. Same for garbage collection. People even used them! Debugging and development books from the 1970s certainly talk about how to go about using these things. It’s just that it was really, really expensive, so it wasn’t widespread (“We ain’t got time to test!”). The key difference has been the advancement of hardware and the ability to actually do it.

                                  1. 2

                                    Indeed, I can’t imagine Brooks’s team made OS/360 without automated testing. And I did plenty of it at Apple in the early 90’s without anyone thinking it was some kind of genius innovation.

                                  1. 21

                                    Developer productivity on Windows comes for me in the form of treating it like Windows, instead of like Linux. That way lies to disappointment. Embrace Visual Studio - it’s a lot better than the Unix crowd gives it credit for.

                                    1. 6

                                      Embrace Visual Studio - it’s a lot better than the Unix crowd gives it credit for.

                                      Honest question: could you give some examples?

                                      1. 3

                                        Mostly the typical IDE stuff; VS just traditionally has executed it well, compared to say, using Eclipse. The debugger, jump to definition, etc. all work very well compared to other IDEs.

                                        1. 5

                                          The debugger, jump to definition, etc. all work very well compared to other IDEs.

                                          It’s funny how since I almost never use these kinds of tools, since most things I work on just don’t require them, I always have a sense that I’m missing out on something, but not only that, I’m also ignorant about it. A kind of knowledge of not knowing what I know.

                                          When seeing all the hype regarding VS Code, as an (avid) Emacs user I think to myself that there must be an entire dimension of improved experiences I could be ignorant about, and then comparing that to Visual Studio proper, simulates a realm of luxury programming.

                                          Then again, whenever I try these things out, I don’t really feel it. There’s a distance between expectation and what I experience, that might not be unlike what first time Emacs/vi users feel… Or maybe it’s just my use-case?

                                          1. 3

                                            You’re not alone zge

                                            The psychology of software & ecosystem comparisons

                                            I have friends that swear by their IDEs. I try to understand them, but I think this fits into the same category of “software A vs B” wars. You will prefer whatever you are used to and consider everything else strange, silly and inadequate when you try it.

                                            For example: I used to use Photoshop CS2 for years. Moving to the GIMP was painful – everything was wrong, features were missing, UI design seemed stupid. Over time I only used the GIMP and learned to love it.

                                            Years later I was put in a reverse situation: forced to use photoshop instead. I found photoshop to be stupid and illogical, especially the UI. I craved for the GIMP.

                                            Another recent example: 3D modelling software. For years I used gMax (an old MAX derivative). I tried blender for a bit and found it made little sense, had a stupid UI and didn’t work the way I wanted it to. Now that I’ve gone back to gMax I’ve found my feelings are mixed.

                                            Really the only good way to avoid these psychological biases is to spend several months or so using both alternatives simultaneously. I’ve never been able to convince myself to use an IDE for long, so I’m not going to be able to give a proper unbiased review.

                                            My biased view on IDEs

                                            Most of my attempts to learn IDEs have been marred by tutorials that are out of date. From what I have seen many IDEs like to change their interfaces and metaphors every few years whilst keeping the same name. I hate this: a tool is not something I want to be a hammer one day and a buzzsaw the next. A good tool is made of stainless steel so that it won’t give me problems down the track.

                                            Of the IDEs I have managed to get working: I end up feeling a bit trapped and restricted inside of them. When a project is designed around a specific IDE/environment there tends to be only “one correct path” to building it, something that sucks if that particular path does not want to work for you today.

                                            Easily being able to get stuff working on someone else’s computer is key for me. I work in education across many devices and servers, doing everything from fixing production database interfaces to helping students with their first programming projects. There is nothing more reliable, stupid and annoying than complex build systems, IDEs or toolchains not wanting to work on some particular laptop or VM; regardless of whether it’s Windows or Linux.

                                            I consider complex build systems (like many of the big make/cmake/etc scripts you see out there) to be somewhat like an IDE. They control how you build, debug and manage your files. They are the “one correct path” to building that particular project. The fact they look different (no GUI, no text editor) makes little difference once things go wrong. When they do go wrong you have limited options.

                                            I really see value in having choice as to how you work on and build a project:

                                            • Can’t install that compiler? Try another.
                                            • Can’t get the meta-build system working? String together a few compiler lines by hand and get it working anyway.
                                            • Need to get the project working on different distro or OS? No need for the latest version of your build system.

                                            I also really see value in:

                                            • Letting people choose their own text editors. There has been some really interesting innovation in this area over the past several years, and changing a text editor is “almost” zero cost if it’s not an IDE.
                                            • Not tieing yourself into one specific debugger. We all have our favourite debuggers and interfaces (this is inevitable, given how complicated they all are). Being able to immediately run a different debugger (GDB, valgrind, scanmem) on someone else’s computer/VM where it has never been used before is a bit like magic.

                                            Finally there’s the ethical issue of the internet and software dark ages. I regularly try to get old games and other programs to work, so this one really bites me where it hurts. I want my code to still be possible to compile or run (with minimum effort) if it’s dug up 10 or 20 years from now. I don’t want it to be a strange artefact that requires arcane software and period hardware controlled by the one last old wisened man to get working again.

                                            Overall: I don’t give a damn how good software is when it is working. I care about my experience when it fails. All software fails and all software has limits, being able to change your tools on the fly (ie not be locked in) is a godsend, especially if you ever have to develop on more than a single device.

                                            1. 3

                                              Visual Studio is super nice, especially if you work in C# or C++. The UI is pane-based, customizable, and simple. The debugger has the usual breakpoints and locals. But it also has tracepoints that can print out things as you execute the program - like printfs that can be changed during execution. It also has immediate mode where you can type in expressions and they’re evaluated in the scope of the function where you’ve broken. All these debugging features save time because you don’t have to keep modifying code and running it over and over again. I recommend using the Vim plugin for Visual Studio. It’s pretty good.

                                              1. 1

                                                In of itself, it wouldn’t seem like anything you couldn’t do with GDB though? Printing out values as thing execute is display. Commands like print can evaluate miscellaneous terms and functions, also within a scope. And while the text mode might be a bit difficult to use, Emacs GUD makes it somewhat more – although not necessarily as pleasant as I imagine VS might be? I can’t say.

                                                1. 1

                                                  gdb can do these things, but the interface for doing so is clumsy. (But it could be much worse too - I had to use dbx more than a few times, and you start to crave gdb after that!)

                                                  1. 2

                                                    But my main question is (for instance): What can VS’ debugger do that I couldn’t with GDB?

                                                    From my world it seems so foreign, I can’t really judge it – is it really more advanced like a human language that could describe colour to a blind person or do we just use different words for “Hello”?

                                                    1. 4

                                                      Some things off the top of my head:

                                                      • you can see your code as you step through it (not possible without some gdb wrapper)
                                                      • there’s a window with lots of variables in it that updates every time you step and highlights any changes (all the gdb wrappers I tried that claimed to have this were completely broken)
                                                      • when your program crashes outside the debugger you get a popup asking if you want to debug it (possible with some signal hacks but it’s complicated and fails all the time)
                                                      • if you use windbg can do reverse debugging too (rr is annoying to set up and failed in very trivial cases last time I tried it)
                                                      1. 1

                                                        I know I sound really defensive, but the first two can actually be done with GDB, by running C-x 1 and C-x 2 (as far as I remember) that display the register/variable contents and the code – but I get your point.

                                                        1. 1

                                                          if you use windbg can do reverse debugging too (rr is annoying to set up and failed in very trivial cases last time I tried it)

                                                          As of 2017, the VS debugger can do this too, at least for C.

                                                    2. 1

                                                      I think you can do most of those things with GDB, but it’s just all much easier with VS. It’s the classic tradeoff between being easy to get started and being able to master tools. A beginner with a 20 minute intro can use all of these tools well without memorizing much. You can always do WinDBG scripting if you want more complex behavior.

                                                  2. 2

                                                    Debugger is one thing, but you don’t feel a desparate need for jump-to-definition / peek-definition? For me, this is a similar sort of leverage as first discovering-and-utilizing auto-complete drop-downs while-you-type, and on-hover (or key-combo) info-tips with doc-comment summaries — impossible to go back and do without. You must have a deeply ingrained personal system for organising what sorts of definitions go in what sorts of file names / dir names — either that, or not minding typing names into search fields a lot.

                                                    1. 3

                                                      but you don’t feel a desparate need for jump-to-definition / peek-definition?

                                                      Oh no, I love jump-to-definition and type previews. They give you a much better feel for the language and it’s sublanguages (libraries, functions, structs/classes/…) – it’s just that non of this is too foreign or hyperadvanced. Even mg (formerly MicroGnuEmacs, a public domain Emacsen) comes with cscope support built in that provides basic support for this kind of discovery:

                                                      C-c s c		cscope-find-functions-calling-this-function
                                                      C-c s d		cscope-find-global-definition
                                                      C-c s e		cscope-find-egrep-pattern
                                                      C-c s f		cscope-find-this-file
                                                      C-c s i		cscope-find-files-including-file
                                                      C-c s n		cscope-next-symbol
                                                      C-c s p		cscope-prev-symbol
                                                      C-c s s		cscope-find-this-symbol
                                                      C-c s t		cscope-find-this-text-string
                                                      

                                                      Again, all I was asking was what VS does that really has no comparison functionality-wise, no real alternative – because that’s the impression I get when people talk about the program, without understanding quite why. I think @qqbear’s take on the issue is probably the right one: same potential power, just easier to learn.

                                                      1. 3

                                                        Again, all I was asking was what VS does that really has no comparison functionality-wise, no real alternative – because that’s the impression I get when people talk about the program

                                                        “Functionality-wise” I think you’ll be hard-pressed to find anything — except perhaps for the vastness of the extensions ecosystem. For anyone who has breathed and lived in their vi/vim/emacs setup for years on end, there’ll never be any compelling “funcionality-wise”. What makes VSCode uniquely smooth and persistently enjoyable is usually for folks coming from big fat laggard bloated IDEs (proprietary or foss) or non-terminal-based “programming editors” with poor extensibility and/or half-baked limited customizability and/or broken/sub-par addon/plugin landscapes and/or missing or sub-par/half-baked integrated-terminals. I can tell you that’s a lot of people and ever more of them converged on vsc and often further added to it via some typescripted additions small or large. The editor is a real productivity upgrade for many coming from say Eclipse / Notepad++ / Sublime / Geany / Textadept / SciTE / VS. It’s the snappiest, near-native-like Electron app around. Your extensions can do many things without ever breaking UX. Whipping up missing auto-completes or go-to-def etc. for not-yet-supported or custom or exotic or config langs, say, is incredibly trivial to first prototype with dummy data, then the real logic.

                                                        Etc. Nothing some 40+-year-old terminal-based editor couldn’t do in its own way with their historically-accrued flavours of key-chords and idiosyncrasies and own well-known mode/script combos. But for the set of folks outlined above, including me, those will never ever become a viable smooth option. Not happening.

                                                    2. 1

                                                      I’ve given VS Code a try, and I would describe it basically as “Emacs for young people” (that is, people who have grown up with GUI applications all their lives and have their expectations shaped by them). It is not more capable than Emacs; in fact, rather less. But it has a hint of the Emacs nature in that it’s extensible in its own implementation language, and people do, in fact, extend it. It heavily uses language servers (LSP) to provide completion and such, much the same as Emacs. Like Emacs, it occupies a space in between simple text editors and IDEs.

                                                      IDEs are just a different universe from text editors…not better, just different. I work on C# on Windows at work, and I prefer to develop in Emacs (with OmniSharp), but manage builds and debug in Visual Studio.

                                                2. 4

                                                  I’d add Powershell for scripting. It’s different than sh, but overall not bad.

                                                  1. 2

                                                    PowerShell is really interesting, I just never had an opportunity to explore it. Even the simple uses impressed me though.

                                                    (Unfortunately, it’s a little slow…)

                                                  2. 2

                                                    Depending on your technology, one of the JetBrains IDEs plus the vim plugin could also bring you far

                                                    1. 1

                                                      I’ll chime in in support of this statement. I’m a long time Emacs user and when I need to do stuff in Windows, I don’t bother with Emacs. It’s a fish out of water. Adapt to the different environment. You’ll be better off for it.

                                                      1. 1

                                                        Depending on your technology, one of the JetBrains IDEs plus the vim plugin could also bring you far

                                                        1. 1

                                                          Agreed! Visual studio is pretty awesome. You should take half an hour to google some useful shortcuts (find all references, go to definition, peek definition, that kind of stuff) and it’s the best editor around. Too bad it’s so slow (and that, when I worked at BigCorp, I had to access it over two remote connections, and had about half a second of lag).

                                                        1. 3

                                                          Tech confession time: I have never used, nor have had any cause to use, git bisect.

                                                          1. 3

                                                            I have only used bisect a handful of times, but I’ve had cause to dozens of times. Basically any behavior that’s reproducible can be isolated to a single commit quickly. The benefits to debugging are obvious, but it’s also useful to get targeted insights into correctly-functioning features and the development of the project (e.g. “who wrote this feature I now need to update”).

                                                            …Unfortunately, it requires a minimum degree of sanity in your history to be effective, which is something the projects I’ve worked on have rarely had (usually due to a combination of nobody caring and policies forbidding history rewriting, leading to broken checkpoints and WiP commits in the “official” history).

                                                            1. 1

                                                              usually due to a combination of nobody caring and policies forbidding history rewriting, leading to broken checkpoints and WiP commits in the “official” history

                                                              Every project I’ve worked on has a history like this (especially legacy ones) and it has never caused a problem with respect to tracking down regressions. But this is probably because there is not a flurry of commits.

                                                              All this is not to say that ‘git bisect’ is useless. Of course not. It’s just that it’s not universal (nor necessary).

                                                            2. 1

                                                              I learned to appreciate git bisect while working at Booking.com, which has a > 1M line monorepo of Perl that literally gets continuous commits to master all day every day. It is truly invaluable to be able to setup a git bisect run to automatically find the commit that’s making your life hard at that commit volume.

                                                              1. 0

                                                                If you do not need to support old versions of the application, then in most cases you do not need bisect at all.

                                                                1. 6

                                                                  I disagree. I find git-bisect very useful when trying to understand when a regression has been introduced, especially if you can use a script to automatically compile and test for the regression. Finding the commit that introduced a regression helps a lot in understanding and fixing said regression.

                                                              1. 1

                                                                This brought back some horrible memories of the OpenCable Application Platform.

                                                                1. 21

                                                                  It would also be a way better email if you dropped all the HTML shenanigans.

                                                                  Composing better emails? Plain text should be number 1 on the list.

                                                                  1. 14

                                                                    Personally disagree on this. A proper HTML link is almost always cleaner than “(see link below)”. You can’t underline stuff (you can “put asterisks around stuff” but…). Sometimes you want to just reference an image inline!

                                                                    There’s a reason that word processors are a big business. Laying out a message nicely aesthetically is valuable for human consumption! The answer to “people always misuse HTML layout” isn’t to get rid of HTML layouts, it’s to teach people how to use it nicely!

                                                                    1. 2

                                                                      I totally get what you mean, but emails are not meant for rich text.

                                                                      Link to a shared document (or an HTML page!) if you need to convey some information that requires media.

                                                                      1. 1

                                                                        I will admit to preferring plain text, but if HTML is used sparingly, it’s fine. That said…

                                                                        A proper HTML link is almost always cleaner than “(see link below)”.

                                                                        This is true, but practically no one does this. Certainly in the 10+ years I’ve been working in corporate environments, no one makes the effort to do a proper link.

                                                                        The answer to “people always misuse HTML layout” isn’t to get rid of HTML layouts, it’s to teach people how to use it nicely!

                                                                        That time has come and gone. The only way this is likely feasible is if you change the tools in some way. Teaching people to use something “correctly” when there are a myriad of (easy) ways to use it incorrectly is a losing battle.

                                                                      2. 10

                                                                        Sorry to be blunt, but I don’t think it’s good that plain text email is such a shibboleth that you can say the equivalent of “I prefer plain text email” without giving any justification or discussion, and it will be the top comment on an article.

                                                                        There are good arguments against HTML email, there are good arguments that we should support some form of formatting, whether or not it’s HTML (see the sibling post by rtpg). Whichever view is right, I don’t think it should just be assumed without any attempt to argue for your opinion.

                                                                        1. 2

                                                                          I’m all for formatting. I regularly use markdown-style formatting in my plain text mails, and I’m an avid user of references[1] for links.

                                                                          HTML formatting in emails is an abomination. Period. It’s a hack. It causes all kinds of issues; it enables phishing, automatic “read notifications” that you did not approve of and difficulties for people with a need for screen readers, just to name a few. Not to mention the security vulnerabilities in clients that have resulted from trying to support this crap.

                                                                          [1] Like this.

                                                                        2. 7

                                                                          I agree but this is not realistic in a world where everyone usees Outlook. I swam against the tides and ran mutt at work for years, until one day I missed a critical update from my manager that used rich text to denote something in red.

                                                                          IMO This is a lost cause, but feel free to rage against the dying of the light :)

                                                                          1. 2

                                                                            Up voted for poetry. :)

                                                                            1. 2

                                                                              Alternatively, you can go work somewhere where the managers use mutt. :) https://boards.greenhouse.io/wikimedia/jobs/1623040

                                                                              1. 1

                                                                                Yup it’s all about choices.

                                                                                I’m willing to run Outlook as my mailer and deal with a bit of large corporate white noise because the value I derive from working here far FAR outstrips those minor annoyances.

                                                                                Everybody has to do their own cost/value curve calculations though.

                                                                              2. 2

                                                                                IMO This is a lost cause, but feel free to rage against the dying of the light :)

                                                                                Don’t worry; I will! https://p.hagelb.org/line.jpg

                                                                                1. 2

                                                                                  +10 for an entirely apropos ST:TNG

                                                                                2. 1

                                                                                  It is of course unfortunate that you missed such an important update. This is where it would make sense to use the Subject header to emphasize the importance of the message, such as the use of [URGENT] or [CRITICAL].

                                                                                  I totally agree that this is a lost cause, but yeah, I will continue to fight for the cause :)

                                                                                  1. 2

                                                                                    It is of course unfortunate that you missed such an important update. This is where it would make sense to use the Subject header to emphasize the importance of the message, such as the use of [URGENT] or [CRITICAL].

                                                                                    It had that, but as I said in the post, it was like:

                                                                                    Blahblahblah

                                                                                    <SUPER CRITICAL STUFF IN RICH TEXT COLORED RED THAT MUTT CAN’T SEE>

                                                                                    blahBLAHblahblah.

                                                                                    So yeah, no hope at all other than “Don’t use rich text.”

                                                                                    In my work environment, I know of literally maybe 2 people in a team of 150 who use mutt. I don’t know what the stats are for the wider company, but I know it’s a TINY fraction.

                                                                                    Expecting my manager to cater to my needs and preferences to this extent is unreasonable in my book.

                                                                                    1. 1

                                                                                      maybe 2 people in a team of 150 who use mutt

                                                                                      OK, but how many are colorblind?

                                                                                      1. 3

                                                                                        You’re preaching to the choir.

                                                                                        I personally think leaving critical information to the vagaries of color is a mistake, but it wasn’t my call. I just need to roll with the punches and deal with the technology environment I’m given.

                                                                                        Yes, I know, I could go work over at $PERFECT_COMPANY and all manner of things would be well, but having to run Outlook and deal with rich text in my E-mail isn’t enough to blunt what is otherwise a really compelling value prop for me in this job.

                                                                              1. 28
                                                                                • Get rid of “hello” and “bye”, along with custom footers. Your name is in the “From” field of each e-mail, and your position can be pulled out from Active Directory or something.
                                                                                • Use double enters to make separate paragraphs. Don’t let your e-mail to be a “wall of text”.
                                                                                • Check typos in your e-mails. Or use a spell-checker if you’re too lazy.
                                                                                • Seriously, being too lazy is NOT a good thing. Really. Don’t brag about it.
                                                                                • DO include a short context about the problem you’re having with some issue, along with a link to the issue. Link itself is not enough.
                                                                                • DO NOT use bold text, or italic text, or different colors of your font, or use it very rarely. There’s 95% chance it will be abused. And it will happen that some people will send very important e-mails consisting of only bold letters (even with the footer), because of such critical importance of such email. And later, when everyone will start using bold letters, nobody will notice them anymore.
                                                                                • HTML can be used for good. Like, for example, using links to issues, not for changing the formatting of the text.
                                                                                • Do not place links to Jira, Redmine or whatever, inline in your e-mail. Use references[1], like this[2], and put the links on the bottom of the message, or use HTML and use normal hyperlinks.
                                                                                • If the company uses top-posting when replying, DON’T reply using inline replies. Same thing in the reverse direction. A good rule can be: use whatever convention is used by the person you’re exchanging e-mails with.
                                                                                • When replying, trim footers of the previous person (you can leave the signature, but again, the name will be visible anyway in the From field).
                                                                                • Don’t use custom characters when using inline replies, use standard one like this: “>”
                                                                                • If pasting code, format it with a monospaced font, or at least make an effort with formatting it, so that the person who will read it later will have it easier. If using text mode and pasting code, consider using ‘#v+’ and ‘#v-’ markers.
                                                                                • If writing a longer e-mail, summarize it on the end.
                                                                                • If writing a longer e-mail, try to put a TL;DR version on the top of the mail. Then, consider if this TL;DR version can be sent instead of the longer message. If yes, remove the longer message and send TL;DR version as the actual message (the longer the message is, the smaller chance is that everyone will read it).
                                                                                • Again, if you’re writing a longer e-mail, double make sure the recipients will understand what is it you ask/expect from them.
                                                                                • If you want to say “I don’t know”, include the next best thing that comes to your mind when you think about a solution to some problem.
                                                                                • Remember that an e-mail is written once, and can be read hundreds of times by hundreds of people. Make an effort to spell-check, format, structure it and minimize it (unless you’re writing a poem).
                                                                                1. 10

                                                                                  I agree with most of your post.

                                                                                  Get rid of “hello” and “bye”, along with custom footers. Your name is in the “From” field of each e-mail, and your position can be pulled out from Active Directory or something.

                                                                                  Custom footers I can see either way. They’re noisy, but it also can be useful context. But do say “hi” or “thanks”. People appreciate some warmth.

                                                                                  If writing a longer e-mail, try to put a TL;DR version on the top of the mail. Then, consider if this TL;DR version can be sent instead of the longer message. If yes, remove the longer message and send TL;DR version as the actual message (the longer the message is, the smaller chance is that everyone will read it).

                                                                                  Good advice. One slightly different spin: if you can’t substitute the TL;DR version, it’s highly likely that you’ve created a document that deserves to live longer than the email you’re writing. Ask yourself whether you should give it a permanent home (e.g. a wiki) after writing the email.

                                                                                  1. 7

                                                                                    But do say “hi” or “thanks”. People appreciate some warmth.

                                                                                    I include these for the first email I send to someone I don’t regularly correspond with, and omit them after that.

                                                                                    1. 2

                                                                                      That’s probably right, I was reacting to what I perceived as a blanket rule. And I suppose I’d never write “bye”, but “best”, “thanks” or something similar.

                                                                                  2. 6

                                                                                    Get rid of “hello” and “bye”, along with custom footers. Your name is in the “From” field of each e-mail, and your position can be pulled out from Active Directory or something.

                                                                                    E-Mail is not instant messaging. In the latter you can omit the greeting/opening, but personally, I consider e-mails without opening and closing just rude. If the reason for the omission of opening and closing is that you exchange a whole series of e-mails with a specific person in a single day, you’re using the wrong medium. Use an instant messager.

                                                                                    Not so long ago, I wrote a (German) blogpost about IM vs. e-mail, albeit it was in a totally different context (security).

                                                                                    As for footers, it is not unusual that they are legally required.

                                                                                    1. 4

                                                                                      It really depends on the context. If you’re writing an e-mail to someone for the first time today, a greeting might not be a bad idea, especially when you’ll probably still use a greeting even if using instant messaging. But I don’t think any further followups or replies require greetings, but still many people use them. It’s not an issue that needs to be resolved, but I just don’t think it’s necessary.

                                                                                      As for footers, it also depends on the context. I don’t think footers are legally required when exchanging e-mails inside the company. They may be required when a person needs to contact people outside of the company. But when such a person sends an e-mail to another person in the company, it can look unnecessary to include a “yes” or “no” answer, following with a footer message that is larger than 2 pages.

                                                                                      Also I can’t agree with the theory that instant messaging is a fundamentally different method of communication than e-mails. It can be used this way; but I don’t think there should be a pressure to reply instantly if a message will arrive on an IM communicator. If I’m busy, absent, or in a bad mood, I don’t answer IMs. I may answer them 3 hours later. I don’t see it as a problem. If a person is in a hurry, there’s always a high priority phone call that can be made.

                                                                                      1. 2

                                                                                        Hello,

                                                                                        Why is it rude in e-mail, but not in your message on Lobsters?

                                                                                        Kind regards,

                                                                                        1. 4

                                                                                          Good question! While your messages in lobsters may be in response to an earlier comment by a particular individual, the norms are different because it’s a discussion board, in which comments are generally meant to be read by many individuals.

                                                                                          1. 3

                                                                                            (Intentionally without a greeting)

                                                                                            Because lobste.rs is not a replacement for snail mail. lobste.rs is not 1-to-1 communication, but a 1-to-many and many-to-one communication.

                                                                                            1. 2

                                                                                              E-mail is also not 1-to-1 communication, I am not the only recipient for the vast majority of e-mails I receive.

                                                                                              1. 1

                                                                                                When I made my original statement, I only had 1-to-1 e-mails in mind. Public discussion media like mailing lists work over e-mail, technically, but are not what I experience as the normal use of e-mail. My original statement applies to the personal 1-to-1 communication, where e-mail replaces the written letter. Letters are not written without openings and closings, and so shouldn’t be 1-to-1 e-mails. I don’t write greetings in mailing list e-mails either, except for the opening e-mail of a thread.

                                                                                                Maybe I’m just conservative.

                                                                                        2. 5

                                                                                          Do not place links to Jira, Redmine or whatever, inline in your e-mail. Use references[1], like this[2], and put the links on the bottom of the message, or use HTML and use normal hyperlinks.

                                                                                          I disagree with this one. Especially in an email with lots of links and/or text. I find it annoying to have to scroll to the bottom, find the corresponding link, then scroll back up and find my place again from where I was reading.

                                                                                          1. 5

                                                                                            Get rid of “hello” and “bye”, along with custom footers. Your name is in the “From” field of each e-mail, and your position can be pulled out from Active Directory or something.

                                                                                            I’ve come around to this.

                                                                                            For those of us who have been around the block a few dozen times, signatures are a hold over from the USENET days, when there was no LDAP or AD or whatever and your .signature was a part of your flair :)

                                                                                            But in today’s corporate world, they’re just extra noise.

                                                                                            1. 3

                                                                                              LDAP and AD does assume it is intra-corporate email isn’t it?

                                                                                              1. 1

                                                                                                Is that really where it comes from? I’d assume it comes from signatures in writing physical letters.

                                                                                                1. 2

                                                                                                  Well, sure, that’s where the word originated, but I’m saying it was popularized by USENET and early E-mail.

                                                                                                  Here’s the USENET “Netiquette” document circa 1993/5 but I’m quite sure it goes back MUCH farther. I know I saw E-mail .sigs in wide use in the late 80s when I was on the internet.

                                                                                              2. 3

                                                                                                Adding to this:

                                                                                                • Avoid using passive voice. It adds more, useless, words. Also, complicates the structure of your text, tiring your readers and sometimes even confusing them.
                                                                                                1. 4

                                                                                                  Passive voice is to be avoided. More useless words are added by it, and the complexity of the structure of your text is increased by it, as well as the energy and sometimes even confusion levels of your readers.

                                                                                                  1. 1

                                                                                                    This sentence is clear, but reading passive voice all day will surely tire you.

                                                                                                2. 3

                                                                                                  HTML can be used for good. Like, for example, using links to issues, not for changing the formatting of the text.

                                                                                                  Agree.

                                                                                                  Do not place links to Jira, Redmine or whatever, inline in your e-mail. Use references[1], like this[2], and put the links on the bottom of the message, or use HTML and use normal hyperlinks.

                                                                                                  Wait what? This seems directly contradictory to the previous statement. Why are links to issue trackers (Jira/Redmine/whatever) exempt from the previous example of good use of HTML links in email?

                                                                                                  1. 5

                                                                                                    I think what was meant was this:

                                                                                                    Please see issue 1234 (https://foo.jira.com/browse/ABC-1234)

                                                                                                    versus this:

                                                                                                    Please see issue 1234 [1].

                                                                                                    [1] https://foo.jira.com/browse/ABC-1234

                                                                                                    If you’re using inline HTML, then it would be an actual link:

                                                                                                    Please see issue 1234

                                                                                                    1. 2

                                                                                                      Yes, that’s what I meant, thanks!

                                                                                                1. 4

                                                                                                  When users fully understand HOW their programs work, they retain their control over the computing experience.

                                                                                                  Here’s the thing: most people don’t care. I’ve wanted to believe that “control over the experience” matters for a long time, and part of my malaise with tech lately has been coming to grips with the fact that for likely the majority of people this is simply a non-issue. This is why environments that offer that kind of control don’t interoperate so well with ones that don’t.

                                                                                                  [Gopher’s] simplicity kept it alive: it requires little knowledge to set-up & it requires little in terms of resources. Gopher has been left unscathed […]

                                                                                                  Not too be too harsh, but this is because no one uses it. Here’s a Gedanken-Experiment: suppose it was Gopher that got popular and not the Web. Do you think Gopher would be as simple today?

                                                                                                  The Web isn’t complicated because developers were negligent, it’s complicated because it attracted a lot of attention and people wanted it to do more. And fast. I agree that it’s over-complicated and it drives me nuts. But I think it’s very wrong to believe that all the stuff we do now that we weren’t doing in the same way 20-30 years ago (and that’s a lot) is boiled down to something as elegant as a pipeline command in the shell. It’s good to fight complexity; it’s folly to think everything is simple.

                                                                                                  1. 1

                                                                                                    Here’s the thing: most people don’t care. I’ve wanted to believe that “control over the experience” matters for a long time, and part of my malaise with tech lately has been coming to grips with the fact that for likely the majority of people this is simply a non-issue. This is why environments that offer that kind of control don’t interoperate so well with ones that don’t.

                                                                                                    People care that their stuff works the way they want it to. They want reasonable defaults, and they want bugs fixed. I don’t think professional software developers can provide either of these things at scale, because the variety of applications is too wide for a professional class to cater to (and thus, more often than not, reasonable defaults aren’t reasonable for all users & correct behavior for one user is a bug for another).

                                                                                                    There are a few alternatives to making a small professional class of devs write a lot of special-casing code for handling a huge variety of actual user cases:

                                                                                                    1. handle a couple of user cases that are more or less representative, and have the rest of the users suck it up or invent their own workarounds based on a vague & warped understanding of how the program is supposed to work. (This is what we do now.)
                                                                                                    2. don’t handle user cases at all, and instead focus on the hard stuff while making the easy stuff easy enough for users to roll their own solutions. (This is what web development was like before it became professionalized, and more or less corresponds to what physicists and linguists end up doing with shell scripts.)

                                                                                                    I think option #2 is basically preferable for everybody (even though it means that the demand for code monkeys basically disappears), but it requires us to make the tools simpler and more available. Already, in many cases, the easiest way for a non-technical end user to get the behavior they want is to learn to code, but we could make things easier for them by designing systems so that making the kinds of shallow changes end users tend to want can be performed with only a shallow understanding of both the language & the rest of the code (i.e., to make most changes desired by end users tantamount to slotting together existing calls).

                                                                                                    suppose it was Gopher that got popular and not the Web. Do you think Gopher would be as simple today?

                                                                                                    I think you’re right that Gopher would have undergone the same change as the Web did, but I think you’re wrong that developers are not basically complicit in this, or that it’s inevitable. We can learn from history, and refuse to implement only-shallowly-desirable features while making sure whatever new features we implement are consistent & scale.

                                                                                                    The sin we committed with the web is naivete: we assumed that, no matter how unstructured and ad-hoc we were, complexity would never add up. We now know that we were wrong about that. We can’t save the web, because the technical debt has been ossified in standards, but the next time we build a hypertext system we can endevour to manage complexity properly.

                                                                                                  1. 5

                                                                                                    I use zsh, and mine is pretty basic.

                                                                                                    [woz@freebsd.local ~]
                                                                                                    >
                                                                                                    

                                                                                                    Username, hostname, current directory (chopped if it gets too long). It also shows the return code of the last command if it wasn’t 0, and will show version control information (branch name, etc.) if applicable.

                                                                                                    Maybe the only slightly unconventional thing is to use two lines.

                                                                                                    autoload -U colors && colors
                                                                                                    PROMPT="[%{$fg[green]%}%n%{$reset_color%}@%{$fg[red]%}%M%{$reset_color%} %{$fg[blue]%}%8~%{$reset_color%}] \
                                                                                                    \$(_git_prompt_info)%{$fg[red]%}%(?..(%?%))%{$reset_color%}
                                                                                                    $(echo '>') "
                                                                                                    

                                                                                                    For the record, I think using a framework for this kind of thing is kind of silly.

                                                                                                    1. 3

                                                                                                      Funny in itself and because he did not cite Regehr and because those irq_chint settings could be legit

                                                                                                      1. 2

                                                                                                        Regehr is cited later.

                                                                                                        1. 2

                                                                                                          Regehr found the example, Bastien thought of scanning through github, and this person posted it as his own idea. Not a big deal - nobody is going to win a Field medal for noticing this - but still it’s not polite.

                                                                                                          Also the IRQ variable is almost certainly using xor as intended to zero the last three bits - it should have been done with defines or constants, but it illustrates the complexity of distinguishing good from bad even for this example.

                                                                                                          1. 4

                                                                                                            It really doesn’t seem that filing this with links to twitter threads is presenting it as their own idea.

                                                                                                            Posting good tickets is also necessary and useful work to be done, I would say they were being helpful.

                                                                                                            1. 1

                                                                                                              but he did not - someone else posted the link.

                                                                                                              1. 1

                                                                                                                Umm the first note in the bug report links to twitter twice. Are you claiming this was edited later?

                                                                                                      1. 4

                                                                                                        The answer is no and the answer will always be no.

                                                                                                        This is one of those cases where pulling on a loose string yields more and more string, which then continues to escalate until the whole construction is in it’s constituent pieces.

                                                                                                        For if the answer would be “yes” as to whether C/C++ compilers should warn on bitshift operators when the user most likely ment exponentiation, then we would end up with the expectation that these compilers should consider programmer intent to be more important than arcane standards and the result would be something that’s no longer C/C++.

                                                                                                        There are hundreds of examples of C/C++ specification lawyering where compilers felt entitled to rely on a strict reading of the specifications to do the unexpected or programmer unfriendly thing, taking “undefined behaviour” as a license to shoot existing codebases in the foot retroactively, usually without warning.

                                                                                                        This is a collective delusion* that’s too late to nip in the bud. One of the distinguishing feature of some newer programming languages (beyond the syntax and semantics) is the vastly different attitude to creating compilers.

                                                                                                        *a bit like how the node community pretends it’s normal to have thousands of separate modules in one’s dependency tree, it’s not normal, but design costs like these are like background radiation

                                                                                                        1. 17

                                                                                                          The answer is no and the answer will always be no.

                                                                                                          Quoting Jonathan Wakely from the bug report:

                                                                                                          There’s nothing wrong about implicit fallthrough, misleading indentation, ambiguous else, or missing parentheses in nested logic expressions either. But people get it wrong all the time.

                                                                                                          Pretty sure the answer is going to be “yes”.

                                                                                                          1. 2

                                                                                                            I’m not sure why you’re equating charging the language semantics with adding warnings, the entire purpose of which is to catch “correct” code that is unlikely to actually have the behaviour intended by the author.

                                                                                                          1. 4

                                                                                                            Then there’s the legacy code that even the owners have disowned.

                                                                                                            Reload is the GCC equivalent of Satan. […] What does reload do? Good question. The what is still understandable. Don’t ask about the how.

                                                                                                            Face it: some code is just garbage, and there’s no easy rule to quantify it.

                                                                                                            1. 6

                                                                                                              “75% of developers” and “75% of developers who chose to respond to a Stack Overflow survey” are two very different things. In my team of 7 devs, I’d hazard a guess that I’m the only one with any non-trivial OSS contributions (and I barely get past ‘non-trivial’, myself).

                                                                                                              The rest of the article doesn’t bring much to the table, either - perhaps not surprising as it is authored by a “Marketing and growth manager”.

                                                                                                              1. 1

                                                                                                                As of this writing, the account that posted this story has posted 17 stories and contributed no comments, and all the stories are to the same domain. I doubt the title of “Marketing and Growth Manager” should be surprising.

                                                                                                              1. 3

                                                                                                                I recently gave up on tiling window managers after some number of years of use. The main reason for stopping was I grew tired of constantly tweaking it to deal with windows that don’t quite fit the tiling mentality. Problems would show up with apps I don’t use very often or maybe just wanted to try out. Windows would sometimes be hidden or seemingly go missing and I just didn’t want to deal with it anymore.

                                                                                                                I’ve since gone back to twm, of all things. I’ve found that placing windows is not really a burden (since it doesn’t happen that often) and it still has simplicity on its side. I’ve never found that integrated desktop environments have helped my “productivity” so I don’t worry about them. I suspect my undercurrent of cynicism comes from the fact that I’ve been tweaking desktop setups for more than 20 years and finally come to terms with the idea that reaching desktop nirvana is most likely never going to happen.

                                                                                                                1. 1

                                                                                                                  I ran twm while working on KDE - specifically hacking the window manager and the panel. Working on something while trying to run it at the same time isn’t fun. I could very quickly kill twm and start kwin to test stuff out, then start twm again, without any disruption to my windows.