1. 1

    Yes please! Medium has a garbage UI, and usually garbage content. I’d enable the filter in a second.

    1. 2

      Hm, interesting that people would get it confused. I guess the article says that in old operating systems there really was a special EOF character saved in the file.

      In the C standard library EOF is just an artifact of the API, a sentinel value outside the range of unsigned char. The C99 spec section 7.19.1 says

      EOF expands to an integer constant expression, with type int and a negative value, that is returned by several functions to indicate end-of-file, that is, no more input from a stream

      It needn’t be -1, but that’s the usual choice.

      1. 1

        Good. Now we are one step closer to git over 9P. Only need to find a couple of person-hours to do it.

        1. 1

          What would be the difference to Microsofts GVFS? https://github.com/Microsoft/VFSForGit

          1. 1

            That was an interesting video. Cool idea to retrieve the file blobs on request rather than up front.

            The motivation section was a little scary though, like how does the windows source code require 270gb? That sounds bloated beyond my wildest imagination.

            1. 1

              I assume there are plenty of non-source-code assets in there: Images, HiDPI icons, fonts, Photoshop files, recordings, etc.

              1. 1

                Yeah must be.

                Another (less intensive than GVFS) way to handle those kind of assets is with something like git-annex. Haven’t personally tried either solution though.

                1. 1

                  We use Git LFS at work and it is quite fragile.

        1. 1

          is possible stored file and meybe git repository on public places? WWW comments, pastebin, twitter, blogs etc.

          Imagine infinite disk and…. anonimity

          1. 1

            This project doesn’t change the storage of git repositories, it merely provides a read-only FTP interface on top.

            1. 1

              if You write comment or paste bin You dont change enything (read-only)

          1. 8

            Working on laarc. https://www.laarc.io

            Traffic exploded since last week. We’re up to >200 accounts, and the graphs are funny. https://imgur.com/a/4CMFcaT

            Laarc got some exposure on HN before the mods whisked the comment to the bottom of the thread. https://news.ycombinator.com/item?id=19126833

            https://www.laarc.io/place is filled up, and I’m not sure what to do with it next. I can’t make it bigger without killing performance. (It’s already unusable on mobile safari.) And it’s probably time to start thinking about the next thing.

            Any ideas for a random project like that? The origin of /place was basically “I think I’ll recreate /r/place today.”

            Laarc also had the dubious distinction of having the first downvoted comment today. It’ll be interesting to see how the community dynamics play out. Some people are asking to get rid of downvoting entirely, but I’m not sure whether that would be best.

            Maintaining >5% weekly growth is really hard. Last week it was “I wonder where I can find +15 people each day.” This week it’s “I wonder where I can find +50 people.”

            1. 1

              Can you explain the vision for laarc? I joined in January at the suggestion of nickpsecurity, but I can’t yet tell what’s special about the site. Looks just like HN, with a large overlap in submissions. Is it the quirky addons like /place, or associated realtime chat rooms that are building a tighter-knit community?

            1. 9

              Whew, that new format is repetitive:

              targets = [ "//:satori" ]
              package = "github.com/buckaroo-pm/google-googletest"
              version = "branch=master"
              private = true
              package = "github.com/buckaroo-pm/libuv"
              version = "branch=v1.x"
              package = "github.com/buckaroo-pm/madler-zlib"
              version = "branch=master"
              package = "github.com/buckaroo-pm/nodejs-http-parser"
              version = "branch=master"
              package = "github.com/loopperfect/neither"
              version = "branch=master"
              package = "github.com/loopperfect/r3"
              version = "branch=master"

              How about a simple .ini?

              name = satori
              libuv/libuv         = 1.11.0
              google/gtest        = 1.8.0
              nodejs/http-parser  = 2.7.1
              madler/zlib         = 1.2.11
              loopperfect/neither = 0.4.0
              loopperfect/r3r     = 2.0.0
              buckaroo-pm/google-googletest = 1.8.0
              1. 6

                TOML certainly is repetitive. YAML, since it hasn’t come up yet, includes standardized comments, hierarchy, arrays, and hashes.

                # Config example
                name: satori
                  libuv/libuv: 1.11.0
                  google/gtest: 1.8.0
                  nodejs/http-parser: 2.7.1
                  madler/zlib: 1.2.11
                  loopperfect/neither: 0.4.0
                  loopperfect/r3: 2.0.0

                More standards! xkcd 792. I’m all for people using whatever structured format they like. The trouble is in the edges and in the attacks. CSV parsers are often implemented incorrectly and explode on complex quoting situations (the CSV parser in ruby is broken). And XML & JSON parsers are a popular vectors for attacks. TOML isn’t new of course, but it does seem to be lesser used. I wish it luck in its ongoing trial by fire.

                1. 1

                  YAML already has wide support so it’s quite odd it hasn’t been mentioned yet

                2. 5

                  Toml can be written densely too, e.g. (taken from Amethyst’s cargo.toml):

                  nalgebra = { version = "0.17", features = ["serde-serialize", "mint"] }
                  approx = "0.3"
                  amethyst_error = { path = "../amethyst_error", version = "0.1.0" }
                  fnv = "1"
                  hibitset = { version = "0.5.2", features = ["parallel"] }
                  log = "0.4.6"
                  rayon = "1.0.2"
                  serde = { version = "1", features = ["derive"] }
                  shred = { version = "0.7" }
                  specs = { version = "0.14", features = ["common"] }
                  specs-hierarchy = { version = "0.3" }
                  shrev = "1.0"
                  1. 4

                    More attributes are to come. For example, groups:

                    package = "github.com/buckaroo-pm/google-googletest"
                    version = "branch=master"
                    private = true
                    groups = [ "dev" ]
                    1. 1

                      Makes sense, I don’t see an obvious way to encode that in the ini without repeating the names of deps in different sections.

                  1. 3

                    Very cool.

                    In practical terms, I wonder when one would want to use Haskell in C versus using e.g., Inline-C in Haskell.

                    I have only tried this once, when trying to write a special purpose static site generator; I had to build a couple million pages as quickly as possible, and Inline-C gave me a significant boost.

                    1. 5

                      Probably if you want a little bit of C in a primarily Haskell project then inline-c would be the most convenient way to go. Whereas boosting a C program with some Haskell parsing or whatever would probably be easiest with this makefile+ghc approach. It also appears that inline-c depends on template haskell, so might be a little slower to build.

                      1. 4

                        Take myself as an example:

                        At my job, we have a data processing pipeline that I developed in Haskell last year. Unfortunately, the “data stream provider” that I used to feed the pipeline is no longer supported inside the company. The currently supported way of doing this sort of stuff is to use an in-house C++ framework.

                        The problem is that rewriting all of that Haskell in C++ is error prone and doesn’t really move the project forward.

                        I think what this post offers will be useful to me. I’ll try to the new C++ framework just to handle to IO part and keep all the business logic in the current Haskell code.

                        1. 3

                          I think the use cases are similar to how we do it in CHICKEN. If you want to use Haskell as a scripting/extension library for a mostly C-based project, I’d use the approach from this link. If you just want to speed up something or do an off-the-cuff C API call, inline C would be the way to go.

                          So basically, it depends if you’re thinking Haskell-first or C-first.

                        1. 8

                          A few notes on this otherwise excellent post.

                          C99 provides a macro SIZE_MAX with the maximum value possible in size_t. C89 doesn’t have it, although you can obtain the value by casting (size_t)-1. This assumes a twos’ complement architecture, which is the most common number representation on modern computers. You can enforce the requirement like this: […]

                          This actually assumes nothing and is perfectly portable because the standard says so.

                          From C89 (draft), “ Signed and unsigned integers” (emphasis mine):

                          When a signed integer is converted to an unsigned integer with equal or greater size, if the value of the signed integer is nonnegative, its value is unchanged. Otherwise: if the unsigned integer has greater size, the signed integer is first promoted to the signed integer corresponding to the unsigned integer; the value is converted to unsigned by adding to it one greater than the largest number that can be represented in the unsigned integer type.

                          The rationale was explicitly to avoid a change in the bit pattern except filling the high-order bits.

                          DOS used \n\r for line endings.

                          As far as I know, DOS used \r\n and Mac OS (classic) used \n\r. EDIT: Mac OS (classic) used \r.

                          OpenBSD provides arc4random() which returns crypto-grade randomness.

                          arc4random() is also available on FreeBSD, NetBSD and macOS.

                          1. 8

                            arc4random() is also available on FreeBSD, NetBSD and macOS.

                            And on illumos systems!

                            1. 4

                              MS-DOS used ‘\r\n’ (in that order). Classic Mac OS (pre-OS X) used ‘\r’ and Unix has always used ‘\n’.

                              The wide character stuff was the most interesting to read.

                              1. 1

                                I stand corrected; thanks. I’ll fix my comment.

                              2. 3

                                Thank you (and the other commenters) for your corrections, I’ll update the article. Learning from the discussion is another great thing about writing these articles.

                                1. 0

                                  arc4random() is also available on FreeBSD, NetBSD and macOS.

                                  This is also helpfully defined in stdlib.h on linux and can be linked to with -lbsd.

                                  1. 4

                                    libbsd is a thirdparty library with its own issues because it can’t decide which BSD to use as source, resulting in different APIs and random breaks when they switched between implementations. https://cgit.freedesktop.org/libbsd/commit/?id=e4e15ed286f7739682737ec2ca6d681dbdd00e79

                                    1. 3

                                      fwiw that doesn’t appear to have affected the arc4random* functions. The core issue seems to be different signatures between the bsds. While changing implementations may be a problem for code using libbsd to port programs, it isn’t as big of a problem for software written with the library in mind. Additionally, the arc4random functions appear to have consistent signatures across the BSDs, so a breacking change like what you linked wouldn’t be necessary. As it is, libbsd is an easy and sane way to get random numbers across different unixes.

                                1. 4

                                  Some of the things in the blog post like := or ?= don’t appear in the posix spec for make. Are they GNU’isms?

                                  1. 7

                                    Yes, along with $(shell ... ). The author should have mentioned he was using GNUMake.

                                    1. 1

                                      := is almost mandatory for makefiles. If you have a shell expansion it will get run every time unless you use :=. Many of the extensions in Gnu make are simply unreproducable in posix make.

                                    1. 1

                                      So how do you manage char* and void* needing to be different addresses? Sounds like a recipe for serious breakage

                                      1. 1

                                        Can you explain the context or machine you have in mind? I don’t know what you mean about these types needing to be different addresses.

                                        1. 1

                                          The article said “This machine uses a different numbering scheme for character- and integer-pointers. The same location in memory must be referred to by different addresses depending on the pointer type. A cast between char* and int* actually changes the address inside the pointer.” And I extrapolated from that to assume no pointer change is necessarily safe.

                                          1. 1

                                            The compiler will translate the addresses properly when you cast the pointers. After the cast it’ll point at the same place in memory, but using a different (type-appropriate) address. The question of when it even makes sense to cast from int* to char* is another matter since that kind of thing might run into endian issues. But yeah the DG Eclipse is an interesting machine and helps discredit the notion that a pointer is “just an address.” Pointers are addresses with types. Of course the type matters when incrementing pointers too.

                                            1. 1

                                              Actually I ran into a case for casting from char* to another pointer type. In stdarg.h the va_list type can be implemented as char*, moved between arguments, and then casted to whatever T* is needed to read the argument as a given type.

                                      1. 8

                                        I’m curious, how many of you are using Mutt as your daily email client at work? How do you cope with calendar invites, frequent HTML emails, …?

                                        1. 3

                                          I use mutt for personal email, so calendar invites is not an issue for me. I also have mutt use lynx to handle the case when the sender only sent HTML (usually, if there’s an HTML section, there’s also a plain text section). For work, I use whatever they give me—I like keeping a separation between personal and work stuff.

                                          1. 1

                                            Do you mean invites aren’t an issue because you don’t use them or because you solved this? If so, how?

                                            I read in another comment that it’s just html, and to be fair as I come to think of it, it’s been a long time since I had to care about mutt and calendars, so maybe it was just a dumb link to click through the terminal browser.

                                            1. 2

                                              I don’t use invites or calendar things via personal email, and if anyone has sent me one, I haven’t noticed.

                                              I did start using mutt at a previous job where I had to chew through a ton of daily mail (basically, all email sent to root on all our various servers were eventually funneled to me) and I found mutt to be much faster than Thunderbird (which should indicate how long ago this was). It was using mutt for a few weeks that prompted me to switch away from elm (which really dates me).

                                          2. 3

                                            IIRC, when I used mutt regularly, I used to have it pipe html emails straight into elinks to render them inside mutt. Didn’t need calendaring at the time.

                                            1. 2

                                              I gave up my resistance of modern email quite some time ago; it’s simply too much hassle, personally speaking, dealing with calendaring and rich media content in email to still use a console based MUA, but that being said I really miss the simplicity and lightweight of Mutt.

                                              Mutt was my go-to client for many, many years, and I feel tremendous nostalgia when I am reminded that it’s still actively maintained and indeed has a user base. Bravo. :-)

                                              1. 2

                                                How many emails do you handle a day? I do about 200, though I need to read or skim all, I only reply to about 1/10th of them… but I can’t imagine keeping up with that in any of the gui clients I have had. With mutt, it feels like nothing.

                                                1. 1

                                                  I’m trying to do more and more with mutt, gradually using the GUI client less. Still haven’t configured a convenient way to view html or attached images but the message editing is nice. I hook it up to vim:

                                                  set editor='vim + -c "set ft=mail" -c "set tw=72" -c "set wrap" -c "set spell spelllang=en"'

                                                  This mostly formats things correctly, and allows me to touch paragraphs up by hand or with the “gq” command. I can also easily add mail headers such as In-Reply-To if needed. In some ways my graphical client is starting to feel like the constrained one.

                                                2. 2

                                                  I’ve been using Mutt for the past 15+ years for personal email and 5+ years for work - even with Exchange IMAP (special flavour) at one point.

                                                  I mostly ignore HTML email - either there’s a text/plain part or HTML->text conversion is good enough - there are occasional issues with superfluous whitespace and it can look a bit ugly when plenty of in-line URLs are being used but these are not that common.

                                                  For calendaring I still use web - we’re on G Suite - but am hoping to move to Calcurse at some point (still not sure how to accept invites, though). Bear in mind, calendar != email, and Mutt is an email client - once you accept it, you’ll be much happier :^)

                                                  1. 1

                                                    I used it 2015-mid 2017 but ended up moving back to Thunderbird and even web clients. It wasn’t worth the effort. If I didn’t have to handle all my configs to get a decent setup (imap, gpg, multi-account, addresses) then I’d consider using it again. I love the idea of not having to leave my term.

                                                    1. 1

                                                      I use mutt daily and have my mailcap set to render html email in lynx/w3m/elinks. It’s sufficient to see if I then need to switch to a GUI mail client. For GUI, I have previously used Thunderbird with DAVmail and currently just use the Outlook client.

                                                      1. 1

                                                        I use (neo)mutt as my daily personal email. HTML isn’t an issue, but forwarding attachments and dealing with calendar invites is embarrassing.

                                                        Usually I use the bounce feature into my work email (Protonmail), which causes spf-related spam flags to get set, but generally gets the job done.

                                                        I self-host my email so the pain threshold is quite high for me to start configuring RoundCube (or whatever the kids today use) or even IMAPS.

                                                        PS. not using Google is a bit embarrassing as well, as the email and Nextcloud calendar are so disconnected, but it works better than mutt ;)

                                                      1. 2

                                                        If votes are actually being counted, I vote nah.

                                                        I haven’t noticed these “growing pains” except in the increasing numbers of dismayed meta posts like this one.

                                                        1. 2

                                                          curl author:

                                                          I’m leaving Mozilla


                                                          curl author is leaving Mozilla!

                                                          me: Uh, OK.

                                                          1. 15

                                                            Supercharge your inbox with our AI Gmail filter

                                                            Giving a third party the right to run code against every email I get is too high a price to pay for convenience, IMO.

                                                            I’m already trusting Gmail (foolishly or not). I just use their spam filters.

                                                            1. 1

                                                              Giving a third party the right to run code against every email I get

                                                              says the gmail user

                                                            1. 7

                                                              Hardware support

                                                              Accelerated graphics: No; Audio: Audio works as expected though there is a known bug [causing it to] stop working after a period of time; Cameras: No; Hibernation: Maybe; Suspend/Resume: No; Wireless: No

                                                              In short, this laptop seems deeply incompatible with OpenBSD. :)

                                                              1. 4

                                                                I wrote the review (and this comment) form it. Seems pretty compatible to me. :)

                                                                I concede that things are 100%, but they never are right out of the gate. Especially with newer hardware.

                                                                1. 2

                                                                  Nice! What about its battery life?

                                                                  1. 2

                                                                    Battery life is not great. I ran for just over two hours with full use (compiling various things, lots of network activity, streaming music videos on youtube). I fully expect it to be much better once things are properly supported.

                                                                    1. 2

                                                                      Thank you.

                                                                      1. 1

                                                                        Which battery option did you get?

                                                                    2. 0

                                                                      an xorg.conf with:

                                                                      Section "Device"
                                                                         	Identifier "Device0"
                                                                      	Driver "intel"

                                                                      might fix your video output as per this bug report.

                                                                  1. 11

                                                                    Thanks Steve, this was a really interesting article. I read somewhere that one reason for the popularity of C is that it has, “a simple yet expressive-enough abstract machine.” Also the term “vaxocentrism” for writing programs against a particular architecture rather than the abstract machine.

                                                                    My next two posts will explore some of the implications of this intersection between portability, the C abstract machine, and how people think about C programs.

                                                                    Looking forward to the posts, and added your RSS to my reader. By a coincidence, a few days ago I bought a copy of the book “Portable C” by Henry Rabinowitz.

                                                                    1. 8

                                                                      Hey at least it’s C++ and not Electron.

                                                                      For my own workflow I’ve found the git command line to be fine for the basic operations. But sometimes resolving merge conflicts can be tricky and for that I use a cheesy little tool called tkdiff. The default color scheme is not too pretty, so I have these color customizations:


                                                                      define bytetag {-background blue -foreground black}
                                                                      define chgtag {-background LightSteelBlue -foreground black}
                                                                      define currtag {-background Khaki -foreground black}
                                                                      define deltag {-background Tomato -font {Monaco 16 bold}}
                                                                      define difftag {-background gray -foreground black}
                                                                      define inlinetag {-background DodgerBlue -foreground black -font {Monaco 16 bold}}
                                                                      define instag {-background PaleGreen -foreground black -font {Monaco 16 bold}}
                                                                      define overlaptag {-background yellow -foreground black}
                                                                      define textopt {-background black -foreground white -font {Monaco 16} -wrap none}

                                                                      It’s nice because the tool has just one function, and you can make it integrate with git by doing:


                                                                      	tool = tkdiff
                                                                      	tool = tkdiff

                                                                      Then when you have a merge conflict, run git mergetool.

                                                                      1. 5

                                                                        I use Meld which is nice, but I’m always on the lookout for something better.

                                                                        1. 2

                                                                          You’ve got Semantic Merge a plain text and semantic diff and merge tool with really good visual component. It supports C++.


                                                                          1. 2

                                                                            Thanks, I’ll check it out.

                                                                      1. 4

                                                                        That textfile blog style is absolutely beautiful. @causal_agent, thanks for putting in the notice on how you created it!

                                                                        1. 1

                                                                          Apart from the repo (https://code.causal.agency/june/text.causal.agency), where can I find more info on the creation by the author? Love it.

                                                                          1. 2

                                                                            Hi! What would you like to know?

                                                                            1. 2

                                                                              I am not yet a *nix nor BSD + manpage pro, but I love the idea of tech posts as man pages / .txt files. Are the .7 source files used for a specific reason? The script for building is so simple, as well.

                                                                              I’m really keen on simplicity these days, especially when it comes to the bloat of the web, so I try to set a good example, and this is something I can learn from for sure.

                                                                              1. 4

                                                                                I’m really keen on simplicity these days, especially when it comes to the bloat of the web, so I try to set a good example, and this is something I can learn from for sure.

                                                                                I’d be the first person to say, “Yeah, make things simpler!” but a plaintext page using spaces for indentation is actually a degraded experience online. The sweet spot for the web is probably a tasteful use of HTML with no Javascript, and a pinch of CSS.

                                                                                Look, even the OpenBSD man pages are rendered online with HTML rather than text. https://man.openbsd.org/mdoc.7 Try resizing the page width and watch how it adjusts to stay readable. Now try different widths with text.casual.agency and look how you get jagged line wrap.

                                                                                Perhaps you’ll argue, “Resize the width, what you do you mean? I’m on lynx!” But even lynx takes cues from HTML tags to render the page better.

                                                                                Finally, you can probably have mdoc output to HTML rather than text and not have to change your page description. Mandoc has a “-Thtml” flag for this, and maybe mdoc has something similar.

                                                                                1. 1

                                                                                  Fair points, and that’s exactly what I was hoping I’d find (when it comes to HTML). Being able to build for .txt and .html files is something I’d like to explore, and you’ve helped. And thanks for the -Thtml lead.

                                                                                2. 2

                                                                                  The extension used for man pages is the digit corresponding to the manual section they’re for. 7 is the “Miscellaneous Information” section which is the only one that fits. You can read about mandoc and mdoc at http://mandoc.bsd.lv, in particular the mdoc(7) page for authors http://mandoc.bsd.lv/man/mdoc.7.html. I might write a little about what I like about mdoc soon.

                                                                                  There’s some interesting background on the build command, mandoc | sed $'s/.\b//g'. When man pages are formatted for display as text, bold text is output as “A\bA” (where “\b” is ASCII backspace) and underlined text is output as “_\bA”, because that was how you achieved those on a teletypewriter. Print A, move back, print A again over it, print underscore, move back, print A over it. Nowadays it’s actually the pager less(1) which interprets those sequences and renders them in your terminal’s bold and underline modes. If you just print the output of mandoc to the terminal, it will look like plain text with no formatting, because the terminal interprets the backspaces and just deletes the first “A” or “_”. The sed command removes those sequences to create a plain text file.

                                                                                  1. 1

                                                                                    Thank you for the detailed response; I had no idea about that background nor why the extension was .7. So interesting! I’ll read up on mandoc & mdoc, and I look forward to your writeup.

                                                                                    Thanks again

                                                                          1. 7

                                                                            This is a complicated issue for me, one that I haven’t really worked out to my satisfaction. I’ll give it a shot here.

                                                                            My first reaction is send the developer a real monetary donation! Gold stars are for kindergarten, you can’t pay bills with stars.

                                                                            But then I don’t think open source is motivated by contractually stipulated monetary reward. It’s more of an artistic expression, a pride in workmanship. Yes it does offer professional exposure, but I don’t think the best and most prolific contributors are fixated on that. They think to themselves, “I’m making this software well and no short-term business objective is going to get in my way. Everyone will see this and be pleased.”

                                                                            Stars are thus saying, “You’ve made something beautiful and true.” It’s shared appreciation, online applause for a performance that has collectively elevated the audience and the performers.

                                                                            However, to continue the concert analogy, great performances do typically sell tickets. This is where open source doesn’t hold up. It’s as if they audience asks, “Can we get in for free if we just clap really loud?”

                                                                            I believe that existing web patronage models are a failure. Look at the average Patreon page – the scale of donations are like an alternate reality. Maintainers collecting like $100 per month total for stunning expertise that provides huge time savings for users worldwide. The fundamental problem with the Patreon model is that the developer has relinquished their leverage the moment they release code under an open license.

                                                                            If I put myself in the shoes of the would-be patrons for a moment, I can totally see their side. Maintainers and bloggers begging for money are ubiquitous, and their requests are vague. After all, they kind of started their projects for nothing and apparently that was good enough for them, so their plea rings hollow.

                                                                            I believe that the only effective model for being paid for open source maintenance is to stop work after a certain point and negotiate contracts with specific people or companies to work on specific features. The idea is that the initial work on a project (which brings it to popularity) is the investment that allows you both to create artistry and gain leverage for future consulting.

                                                                            This is still a second-class arrangement compared to businesses based on selling products or rentals because it cannot scale beyond paid labor. The consulting rate may be high, but if you stop working on the project that’s the end of your pay from that project. By contrast, authors who sell physical books or training videos make the artifacts once and then enjoy revenue proportional to number of people buying those artifacts.

                                                                            Would that I could truly internalize this capitalist mindset. There’s just something seductive about open source software – it feels like it’s the only thing that actually stays relevant in the long term. The commercial stuff gets warped and fades away. Freedom from commercial obligations and deadlines means that open source maintainers retain the independence to do things correctly.

                                                                            Developers working together on OSS form an intellectual bond that spans nations, almost like the scientific community. It’s the software created (or the scientific truths discovered) that unite people and elevate them beyond their otherwise monotonous striving for money and physical comforts.

                                                                            I’ll end this rant here. Perhaps I’ll never reconcile these two viewpoints, the material and spiritual you might call them.

                                                                            1. 2

                                                                              I rely on the Godot engine nowadays, but don’t really have money to spare. I’d love to contribute to their Patreon campaign, but there are specific features I’d need, and I don’t think they’re a priority. So it’s hard to direct money into specific problems. Bounty programs would be more specific.

                                                                              Everything about this is hard, though. Having money stuck in a bounty escrow is not advancing anything. Contract negotiation and international billing has a lot of overhead, and may turn out to not advance anything. Not paying anything, money or code, doesn’t necessarily advance the project.

                                                                              C’est la vie, I suppose.

                                                                              1. 2

                                                                                The money really has to come from businesses. It’s so easy to say “Hey, this JetBrains IDE I need costs $200” and that will get approved right away because it has to be paid for and it makes me much faster as a dev but saying “This open source library we use is asking for donations” will not get approved because it doesn’t have to be paid for. The most I can do for OSS we use at work is send bugfixes upstream.

                                                                                1. 1

                                                                                  IMHO this is a very useful observation. Maybe we should build a culture that tolerates little paid gimmicks on top of open source projects so that you can justify what’s effectively a donation.

                                                                                  1. 1

                                                                                    This seems to be the way many OSS projects run now. The core is open source which usually has everything individuals need and then extras are proprietary which are needed for large corporate projects. Its called “Open Core” for people who want to search it. Gitlab even has the source for the paid features public but the license doesn’t let you use it without paying.

                                                                                    It does have some issues though. The major one being what happens when someone replicates your paid features. Gitlab says they will accept pull requests that recreate their paid features but they also have the resources to create 20 more by next month. As a solo dev, having someone recreate your paid features could cut out all of your revenue.

                                                                                    1. 1

                                                                                      I think this gimmicks can very effectively be access oriented. Custom slack channel, custom email address, custom phone number, access to a special meeting. Not so much a feature they get over others, but access to the team they get over others.

                                                                                    2. 1

                                                                                      It might also not be paid for because the value isn’t as obvious. A bounty-style deal might get approved, because you’re essentially paying for something you require.

                                                                                      It’s a question of the direction of the funds and value. This is very obscure when asking for donations in general, don’t you think?

                                                                                  2. 2

                                                                                    A lot of great stuff in this comment I want to reply to!

                                                                                    My first reaction is send the developer a real monetary donation! Gold stars are for kindergarten, you can’t pay bills with stars.

                                                                                    I actually think you hit the nail on the head with your first out of the gate recommendation. I think no matter how small your project is you should put up a Patreon or a Bountysource or similar. Not just for yourself for paying bills – but for the people who want to feel involved but can’t do so directly. The patreon model is about supporting what you love. Regardless of the platform you use, you can display you patreon count.

                                                                                    The fundamental problem with the Patreon model is that the developer has relinquished their leverage the moment they release code under an open license.

                                                                                    I fundamentally disagree with this. It simply isn’t about leverage. It is about eyeballs and goodwill. Look at DTNS – the show is free to listen to for all – heck, it is even free to remix how you want as it is released under creative commons. It brings in $18,000+ monthly because it feels good to support it and the perks it offers feel relevant.

                                                                                    I think it is about being savvy in regards to perks, and initial market. Developers were not the initial target for Patreon, there isn’t a lot of crossover there. That said, I think many projects could have very successful Patreon setups if they tried. Some of it is about tiers, if you want to get into the Slack channel it takes a an investment. The investment could be time and code or documentation, or that investment can be $5 a month. If you want to sit in on the monthly feature discussion roundtable – $40 a month or direct contributions at a level that you are invited, etc. If you want to get the project leads home phone number, be a sustaining supporter at $1000 a month for at least 6 month – etc.

                                                                                    After all, they kind of started their projects for nothing and apparently that was good enough for them, so their plea rings hollow.

                                                                                    Which is why you put up the Patreon feature early, so it doesn’t look like some bolt on or beg later. It is there from before anyone would consider contributing. Neovim had this as a bolt on after the initial funding push, and while I find their pitch possibly too gentle, at least it is there at the bottom.

                                                                                    to stop work after a certain point and negotiate contracts

                                                                                    This is devastating to good will, and will encourage forks so someone can take your work and be the more well known version of it with those +3 features. I do not think this is a good way forward.

                                                                                    (and one last mostly irrelevant reply)

                                                                                    But then I don’t think open source is motivated by contractually stipulated monetary reward. It’s more of an artistic expression, a pride in workmanship.

                                                                                    I honestly think far more work is done in anger than for artistry. In market terms, more “painkillers” than “vitamins”, doubly so in open source. “The bleep won’t beep bleep bleep what type of bleep bleep wrote this. I will just fix it, bleep it!”

                                                                                    1. 2

                                                                                      But then I don’t think open source is motivated by contractually stipulated monetary reward.

                                                                                      I guarantee that is sometimes the case. I’ve been turned down offering to pay for work on FOSS projects or public sites specifically because the developers and admins wanted to keep money and its psychological effects out of that part of their work. They were doing it for ideology, charity, fun, and so on. They had other work they did for money. They kept them separate.

                                                                                      I still advise offering to pay the going rate for work just in case they need it. If they refuse, maybe a cup of coffee or lunch for thanks. If they refuse that, then a heartfelt thanks, star, and whatever since they’re some really devoted people. I won’t say selfless since some do it for not-so-nice reasons and the good ones get personal satisfaction from the good they do. Definitely dedicated or devoted to helping others with their work without asking for something in return, though. I respect and appreciate those people. I also respect the ones doing it for money since they might have been doing something without large benefit or benefiting companies like Oracle hurting us all.

                                                                                      EDIT: Someone might wonder what I meant by not taking money for not-so-nice reasons. I’ll give a few examples. One is academics who release code as a proof of concept and/or with potential to benefit people if someone else works on it. They’re paid and promoted for output of papers, not maintainable FOSS. Many would refuse offers to extend older projects. Proprietary software vendors doing OSS side-projects and/or open core companies might refuse paid work on their FOSS because the features compete with their commercial offerings. Regulated industries using some FOSS or OSS components that had to be certified in expensive process would have to recertify them to use modified forms. They often don’t do bug/security fixes for this reason. They might turn down offers on specific libraries. Finally, some people might want the software to work a specific way for arbitrary reasons and/or straight-up hate some potential contributors for personal attributes. There’s a religiously-motivated project whose maintainer fits that description.

                                                                                      So, there’s some examples of maintainers that would turn down money for reasons having nothing to do with selflessness.

                                                                                      1. 1

                                                                                        It is basically same as science. Which is also tragically broken due to funding (and valuation) issues.

                                                                                        If only there were a global fund for free projects that would map their dependency tree, perform some health-checking and distribute donations in a predictable fashion…

                                                                                        Then a government or a company relying on free software might donate with indications on what to support. Gov. might, for example, donate 1% of purchased software project price to it’s dependencies or require the supplier to do so… That would be about €5.000.000 a year just for Czechia.

                                                                                        1. 1

                                                                                          My first reaction is send the developer a real monetary donation! Gold stars are for kindergarten, you can’t pay bills with stars.

                                                                                          I’m afraid that for most people, the hurdle to sending money over the internet is much higher than telling them they like what is done via a star (or analogous system)…

                                                                                        1. 1

                                                                                          Everything starts with the commits. Their text is your first line of defense. Think of this as what will appear in the logs.

                                                                                          Interestingly, commit messages have seemed to shrink ever since people started using pull requests. GitHub focuses attention on the pull request description and subsequent comments, and de-emphasizes the commit messages which it displays in a smaller font. By default GitHub pull requests hide multi-line commit messages until you click a plus button to expand them. The net effect is that people consider the PR as the artifact of interest and the commit as a trifling accessory.

                                                                                          Perhaps this was an intentional design choice, because it means if you ever want to migrate to another git hosting service then you would lose the bulk of the communication metadata (that they guided you to store outside the repo itself).

                                                                                          Compare your typical commit messages to those in the Postgres project (where they don’t use pull requests):


                                                                                          …or in Linux, which also stays away from GitHub:


                                                                                          1. 5

                                                                                            To be fair, both of your examples are “real” projects, instead of, say, web stuff or Javascript frameworks or something.

                                                                                            My commit messages back when I was working on low-level C libraries and things were leagues better than what I do today, since there tended to be a lot less of change margin to align with newsletter-type issues. Different engineering cultures.