Havoc Pennington

• <https://www.freedesktop.org/wiki/IntroductionToDBus/> • <https://www.freedesktop.org/wiki/Software/dbus/> • <https://dbus.freedesktop.org/doc/dbus-specification.html> • <https://blog.ometer.com/2007/05/17/best-d-bus-practices/>

Linux distributions have been including the major version in the name for a long time; when we started doing this at Red Hat I wrote down the rationale at http://ometer.com/parallel.html in order to convince upstream projects to do this upstream, as many now do. For non-system package managers like npm, always using a lockfile is the best current option IMO, for those package managers that support it. https://blog.ometer.com/2017/01/10/dear-package-managers-dependency-re…

1. Kathy Sierra's book "Badass": how to make users of your software or product succeed. 2. Tooting my own horn: I've been trying to think about this, and write up what I've learned over the years. Like, what it takes to be a productive programmer (https://codewithoutrules.com/2016/08/25/the-01x-programmer/) 3. Havoc Pennington's blog has some amazing stuff, e.g. https://blog.ometer.com/2016/01/26/the-dangerous-ui-team/ 4. A book on writing (I found one I really like, but it's out-of-print - https://codewithoutrules.com/2016/06/15/writing-book/) 5. Maybe some of Gerald's Weinberg's books? 6. "The Clean Coder" has some useful bits too.

I would actually recommend against starting by launching your project. Havoc Pennington (GNOME guy) wrote "Working on Free Software" in 1999 to explain why. In my opinion every word there is still valid today, with possible exception of CVS. http://ometer.com/hacking.html And you see, it was called "free software" back then, not "open source project". Sigh.

Havoc Pennington makes a similar point in his essay "Working on Free Software" (http://ometer.com/hacking.html): "Eric Raymond's thoughts on this topic are here; his HOWTO describes how to join "hacker culture." The culture isn't really necessary to participate in free software projects though, IMO. As long as you follow the community way-of-working you don't have to get into the social aspects (unless you'd like to)."

This opinion of "Gnome is killing customization" is something I see quite a lot, but which I think people take the wrong way. It's absolutely true that Gnome is designed to be less themeable than other DEs like KDE, or individual WMs - and by extension, GTK apps and apps designed to be used on Gnome are harder to customize/break more when you do theme them. But I disagree that "customization of Linux [being] half-dead" is a bad thing; on the contrary, I support the lack of theming options, and I like that there's someone on the Linux desktop that pushes this hard for consistency. To make my biases clear: I'm a software developer that uses Gnome daily, and is developing a GTK/Adwaita app. I used to rice a lot back in the i3 days, but I don't particularly care about that nowadays, and stick to the defaults when I can. For my purposes, GNOME and Adwaita is perfect since it's very opinionated by default, and you can make good looking apps with minimal effort. Since all Adwaita apps are supposed to look similar and follow the same HIG, most of my desktop apps have the same look - but more importantly, the developers of the apps can also be confident that their apps look correct on my desktop. This is something that developers in the GTK space generally want, and for good reason[0]. One argument is that you as a user of the desktop should be able to have the final say on how your apps look, which is a totally valid take! And there are DEs, WMs, and apps which give you this…

Why is GNOME like GNOME? https://ometer.com/free-software-ui.html I recommend to read this! You will understand a lot about GNOME. They learned a lesson to keep things simple for the user. But the reason for five clocks is probably, that neither provides the important preferences for a lot users. Ubuntu Please don't think that Ubuntu is using GNOME. It is a massively patched and themed version of GNOME, mixing package versions of current and older versions. And more important, for many years Ubuntu used Unity as UI and and own Login-Manager. Canonical is always doing something alone outside of community. The good news * Canonical helps GNOME since some years again and it has an positive effect, lots of performance improvements. * GNOME is keyboard centric! I select applications windows by typing the application name. Why search if GNOME can find it? * Luckliy GNOME removed the entire failed desktop metaphor from Microsoft Windows (arranging and searching icons you never see and never use because a windows is in front of it). * And the SystemTray (Microsoft tries to hide it since Windows XP). Either your a silent daemon or an application with an CLI, TUI or GUI. * GNOME is incredible friendly to new users which doesn't expect things already in a specific way. * They learned a lot and re-added features. Like the awesome file type-and-find in Nautilus. The bad news GNOME tends to remove features and options before an appropriate replacement…

> Adding features and settings is fun and often done without much second thought. In the end, it results in a bloated beast that causes a lot of confusion and frustration, especially among the type of users most open-source projects are missing, the average user who just wants to get things done. A few large open source projects have tried to improve usability by removing features and options. Look at the history of Gnome 1 through 3. Professional UI experts were paid to produce usability advice for Gnome[1], and the Gnome developers responded with the wholesale removal of configuration options across dozens of major programs[2]. Mostly I actually liked this, because I prefer clean programs that I don't have to mess with. But a lot of other users were unhappy, because many desktop Linux users prefer knobs. Which is fine! But what about Windows users and open source applications? Here, success may be more of a mixed blessing. I've heard several open source maintainers say that their Windows users are more likely to get angry with volunteer maintainers, and to display the sorts of behaviors mentioned in [3]. So widespread popularity isn't always a goal. Sometimes people just want to make a niche tool for other enthusiasts. So it's worth asking whether any given project is seriously trying appeal to "the average user who just wants to get things done." Some are, some aren't. [1] https://people.gnome.org/~calum/usability/ut1_report/report_main.html [2]…

That's part of the philosophical change that led to GNOME 2.0 https://ometer.com/preferences.html

Reminds me of https://blog.ometer.com/2011/01/20/boolean-parameters-are-wrong/

All I can say is that GNOME 3 seems to take Havoc Pennington's famous essay about as far as it can go, considering configurability a bug. I don't know exactly when it started, but it definitely came to my attention bigtime with the infamous gnome-screensaver. Useful links: 1. https://ometer.com/preferences.html, the subset of Mr. P's original essay that the original contains a link to. 2. https://www.derstandard.at/story/1313024283546/gnome-designer-jon-mcca… an interview with Jon McCann.

Do you have an example of a nontrivial user-space project that has malloc failure handling that actually works, with tests and all? The one I'm aware of is SQLite. Then there is DBus, whose author disagrees with your assessment. https://blog.ometer.com/2008/02/04/out-of-memory-handling-d-bus-experi…

Here is a comparison of json like formats by the author of HOCON: https://blog.ometer.com/2015/09/07/json-like-config-a-spectrum-of-unde…

Very true for low-level system libraries, but applications should really not waste energy on trying to be OOM-safe: it's hard to understand which actions are safe when you no longer can allocate memory (releasing resources often requires allocating memory temporarily), and it just adds complexity which basically will never get tested, thus getting broken quickly and gaining nothing over just crashing on a NULL dereference. See the experience of the D-Bus (which tries hard to be OOM-safe) on this topic: http://blog.ometer.com/2008/02/04/out-of-memory-handling-d-bus-experie…

I think you'll find this post interesting: http://blog.ometer.com/2011/01/04/asheville-off-the-tech-hub-grid/

What caused this mess? Some historical deliberation on that question, in a broader context, by Matthew Paul Thomas: http://web.archive.org/web/20051030040127/http://mpt.phrasewise.com/20… Havoc Pennington: http://ometer.com/free-software-ui.html

Havoc Pennington wrote recently about synchronous and asynchronous APIs, with an interesting analysis of the differences between (synchronous) callbacks and (asynchronous) events. He suggests that a call­back should be either always sync or always async, as a doc­u­mented part of the API con­tract. Callbacks, synchronous and asynchronous: http://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchrono…

I was also there and jdub is correct. This retelling of history is nonsense. Especially this part: > SUSE, Red Hat, Debian, Ubuntu, even Sun Solaris used GNOME 2. Everyone liked GNOME 2. The default DE on SUSE was KDE. If you wanted GNOME you had to request it explicitly at install time. But more importantly, GNOME 2 was enormously controversial. It split the Linux and GNOME communities, it was the systemd flamewars of its day. The developers had to constantly justify themselves and received endless flames and hate mail about it. In fact it went OK because, just like with systemd, it turned out that there was a silent majority who did like the new direction of GNOME and become enthusiastic adopters, but the idea that everyone liked it is just absurd. Also, GNOME 2 didn't have a Win95 style interface. GNOME 1 was Windows 95 inspired, GNOME 2 was clearly a reaction to macOS although it managed to establish a unique art style and personality as well. The drivers of the new direction for GNOME 2 were Havoc Pennington and Calum Benson at Sun (who did a usability study on GNOME 1). Pennington spent a lot of time explaining to Linux hackers that more options and preferences wasn't always better. For example in this essay: https://ometer.com/preferences.html Both GNOME1 and KDE were basically direct mappings of the Linux CLI experience to widgets; it was common to have checkboxes in apps with labels like "Use Xrender", no further explanation provided. Pennington revolutionized…

>Ok, next question: Why do you need window handles the size of interstate freeways on devices without touchscreens? It's not like it's impossible to detect the current hardware configuration. Because options run counter to the gnome dev philosophy. That can be traced back to the original Havoc Pennington rant to defend Gnome 2.0 (which was actually a controversial release just like every major gnome release since 1.4) : https://ometer.com/preferences.html >Preferences substantively damage QA and testing. >As someone who reads dozens of bug reports per day, and occasionally fixes a couple, I can tell you that it’s extremely common to find a bug that only happens if some certain combination of options are enabled. >Upshot: more preferences means fewer real features, and more bugs. Of course, what you propose isn't a preference but automatic detection, but the point still remains valid in terms of their philosophy. >One of the hardest lessons of GUI programming is that hard coding behavior can be the Right Thing. Programmers are taught to make everything generic and infinitely flexible. The problem is that the more generic and infinitely flexible your UI is, the more similar it is to a programming language. Lisp is not a good user interface. These are the same reasons why they canned anything related to screensavers and the likes. Gnome should not be customized, should have brand identity, should not have options whether they are user selected or automatically…

Looks at correct-mkdir. Sees "cb = dezalgo(cb)". https://www.npmjs.com/package/dezalgo "Contain async insanity so that the dark pony lord doesn't eat souls" Just... What. I feel like when you need to reach for tools to "contain insanity", you might want to backup and ask someone who has written to a filesystem before... The linked blog about "preventing the release of Zalgo" and the linked https://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchron… seem completely erroneous. The entire point of callbacks is to _surrender_ control to a function - here is a piece of code to run when you are ready - now, sometime, or never, or maybe many times, as you see fit. Waiting until the next process tick seems so completely unnecessary... This strikes me heavily as "a solution in desperate search of a problem" - although I have that feeling with a _lot_ of NodeJS code I read... The author of the blog linked on the dezalgo project seems to, at the end of the post, imply the purpose is for performance? By deferring work until a later date? "The basic point here is that “async” is not some magic mustard you smear all over your API to make it fast. Asynchronous APIs do not go faster. They go slower. However, they prevent other parts of the program from having to wait for them, so overall program performance can be improved." Other parts of the program _other than the work we've asked it to do_? What if we're only "correctly making" one directory? So we intentionally make…

> That's not user friendly customization 1) You were arguing in your original post that the default is good for a target audience of non-power users, but not for power users. However, power users should be able to go through the dead-simple extension two-click installation process. So you're contradicting yourself. > Couldn't this be a simple checkbox integrated natively into GNOME 3 instead of a third party download? http://ometer.com/free-software-ui.html "The question of preferences" > Why is the accessibility menu there by default in the first place if very few people are going to use it? It's just an icon, no one has to click it. But it's there for those who need it. Why make it harder for them while others have no loss with the icon being there? And everybody will need it at some point in his life. 3) e.g.o is not meant as app store. Extensions are not intended to be apps. 3b) Automatic updating: it's coming with Gnome 3.6. Source code: You can see the source code of every extension under .local/share/gnome-shell/extensions/. It's plain JavaScript. > Is it curated or can anyone upload malware there? Extensions go through a review process. You could have figured that out by looking at https://extensions.gnome.org/about/ "Are GNOME Shell Extensions safe?" 4) Power users and extension developers do not want to wait for the next distro release in order to have fun. Same rationale for browser extensions. 5) https://extensions.gnome.org/about/ "Are GNOME Shell…

I think the opinions expressed in this article are valid. However, I don't think the inability of current JavaScript to do async I/O without callbacks is Node's biggest problem. As others have said, it works for smaller projects (and even has some geek appeal). And as Havoc Pennington and Dave Herman have explained, generators (which are coming with ECMAScript Harmony) and promises will eventually provide a very nice solution. So Node has a path to grow out of the callback model without giving up its single threaded paradigm. http://blog.ometer.com/2010/11/28/a-sequential-actor-like-api-for-serv… http://blog.mozilla.com/dherman/2011/03/11/who-says-javascript-io-has-… The bigger problem (which I don't see getting solved anywhere down the road) is the lack of preemptive scheduling, which is available in Erlang or on the JVM. What you see under high load with Node is that latency is spread almost linearly over a very wide spectrum, from very fast to very slow, whereas response times on a preemptively scheduled platform are much more uniform. http://jlouisramblings.blogspot.com/2010/12/differences-between-nodejs… And no, this is something that can't be solved by distributing load over multiple CPU cores. This is problem really manifests itself within each core, and it is a direct consequence of Node's single threaded execution model. If anybody knows how to solve this without resorting to some kind of preemptive threading I'd…