Linus Torvalds Receives 2014 IEEE Computer Pioneer Award
computer.org
computer.org
http://www.youtube.com/watch?v=4XpnKHJAok8&feature=youtu.be&...
If you integrate source control with issue-tracking, you start to want source code changes to correspond to issue numbers, and changes to be pushed if an issue is in a certain state or owned by a specific developer. But you can't get this information when you are offline without access to the issue-tracker.
Either there's a case for distributed issue-tracking too, which would give you that information, or issue-tracking being centralized pushes back on source control wanting to be distributed.
I wish this was addressed in Git's assumptions.
He was definitely right about that, what I like about Linus is he really does seem to prefer to do things in as concrete and simple a way as possible instead of getting mired in abstractions.
This muddled language later turned into a muddled UI that was supposed to get cleaned up, but never did.
I'm pretty sure the only reason git took most of the mind share instead of hg was (1) github (2) Linus admiration.
- git has an 'email' centric workflow
- The index with git (git add -i) awesome for people doing patch maintenance
- the rebase workflow is great when you want to maintain against an upstream that you expect someone other than you to commit your changes to, or you have a "pre-publish" phase.
It's almost like those reasons follow the linux workflow.. almost perfectly.
My workflow for a lot of the projects I contribute to is something like:
edit -> commit (repeat as necessary) -> rebase -i -> format-patch -> send patchset by email
Which is surprising, given how rough all the email-involving commands of git are. Badly documented (git-send-email man page doesn't even come close to documenting all options properly), awful error reporting and a badly explained (although, in itself, quite sane) workflow when sending the patches.
When setting up my email setup, I consulted the underlying Perl script more than the docs :(.
That's a good observation. Git seems to assume its distributed issue-tracker is email.
- Mercurial also has an email-centric workflow, look at its mailing list: http://mercurial.markmail.org/search/?q=#query:+page:1+mid:p...
- The staging area can be achieved in hg in several ways, or it can be avoided as desired. One easy way is to just pick apart your commit with hg (c)record --amend and just keep adding to your commit as necessary.
- Rebasing has also been available in hg forever (and wasn't available in git from the beginning). We also have some really interesting changes brewing for rebasing in Mercurial: https://www.youtube.com/watch?v=4OlDm3akbqg
These ideas in hg were all for following the Linux workflow too.
Nothing against git, but it's important to not deify Linus as if he were a unique genius. He has his flaws, and so does the software that he's responsible for.
Mercurial beat git past the starting gates, but git has the advantage of being used on a very widely used, widely developed, immensely high profile project. While Hg has its own commendable set of projects, git has simply won the mindshare battle.
Could be worse: there's arch and bzr and probably some others.
Hell, even GNU/EFF are looking to ditch their own VCS in favor of git from what I understand.
GNU Emacs decided to switch from bzr to git, but GNU as a whole doesn't have a recommended VCS yet. In GNU Octave we will keep using hg. I don't think the EFF is too public about which VCS they use.
But yes, I meant "FSF", not "EFF".
Hg eventually came around but, for me, the damage had been done. It's the second biggest reason I went with git.
(The biggest, of course, is you use git if you want to interact with kernel devs. But lots of kernel devs hated git in 2005/2006. Mercurial had a reasonably big window of opportunity... all imo, fwiw)
There's a strong aversion of using tools done in Python outside of Python community. It is irrational, but it being an inherently interpreted language puts it into the same perception bucket as Perl and who'd want to use a control system written in Perl?
> So I've been thinking about this for basically months, but the way I work, I actually want to have a good mental picture of what I'm doing before I start prototyping. And while I had a high-level notion of what I wanted, I didn't have enough of a idea of the details to really start coding.
So two weeks seems reasonable to me, especially if he built a prototype first. (Did he?)
1: https://plus.google.com/102150693225130002912/posts/X2XVf9Q7...
I think that git commit, init, add, fetch, branch, checkout, merge, and push all have sane defaults and anybody can pick up very basic git usage using those commands in less than a few hours.
Things get complicated when you start looking at the details, but I don't see any way around that. And the interface doesn't change. It's just a matter of learning more flags and commands.
"I don't know how to use git"
or
"I don't know how to alias complex commands I use frequently"
Maybe you'll have better luck with the responses you get :)
It's very un-Unix.
Then again, I alias nearly all the CLI programs I use frequently. Grep's recursive search is aliased to `sr`, Python to `py`, Django's `manage.py runserver` to `run`.
That, and runit has been around for a while, though I don't know much about it.
[1] https://lkml.org/lkml/2012/12/23/75
[2] https://plus.google.com/u/0/+LinusTorvalds/posts/1vyfmNCYpi5
Edit: No need to be as explicit as Linus to be sarcastic.
Many moons ago in an organizational behavior / group decisionmaking book whose title I can never keep in mind, I read a fascinating chapter on various group structures for decisionmaking.
Of the various models, the one which works best under more circumstances is that in which there is a leadership role (so there's no indecision over what decision has been made or when it's been taken), but that role is collectively assigned based on merits.
In other words, the leaders' tenure is at the consent of the group as a whole, and can be transfered. The one decision over which the leader has no effective say (or at least: no more than any other individual) is over the question of leadership.
Strikes me as very much the model that's followed by the most successful free software projects.
I believe Linus learning some manners for himself would hardly slow down neither of Linux or Git, and nor would make him a lesser leader. Seriously, there are better ways of putting things forth, than execrating persons who contribute to Linux/Git for a living, on public mailing lists. Leaders need be responsible of their public speech. Someone who is writing curse words in all caps is not speaking responsibly by definition.
In both cases, the result doesn't seem to have hurt what matters: the project themselves and the utility they provide their users.
The goal of the projects isn't to protect tender egos. It's to get shit done and make the right decisions.
Linus answered one woman who'd criticized his behavior by noting that a key issue for him was making absolutely unambiguously clear how good or bad a given technical suggestion was. And he does that.
Here we go: https://plus.google.com/102150693225130002912
Because if you want me to "act professional," I can tell you that I'm not interested. I'm sitting in my home office wearing a bathrobe. The same way I'm not going to start wearing ties, I'm ALSO not going to buy into the fake politeness, the lying, the office politics and backstabbing, the passive aggressiveness, and the buzzwords. Because THAT is what "acting professionally" results in: people resort to all kinds of really nasty things because they are forced to act out their normal urges in unnatural ways.
As I commented at the time:
There's something to be said for being an equal-opportunity asshole, in a fair and balanced manner.
And in running the most effective, successful, beneficial, and largest OS development project the world has ever seen.
I see Linus's behavior as being an instance of Celine's Second Law:
Accurate communication is possible only in a non-punishing situation.
https://en.wikipedia.org/wiki/Celine's_laws\#Celine.27s\_Sec...
"Huh?" you say? But Linus is punishing communication.
No. Linus is communicating. He's expressing a clear view of what is or isn't valuable. The punishment isn't in rating the quality of contributions to the kernel, or usefulness of others' participation in the LKML. It's in criticizing the communications methods used to convey that feedback.
Yes, it may be insensitive. But fuck sensitivity
We've already got a world with multiple inits. The rationale for adopting systemd is ... troubling. Clearly, Linus has some issues with the team involved, though I don't know whether or not he's also concerned with the deep coupling.
Hauling systemd out of udev (or offering a systemd-free alternative) would also make me far happier.
Complexity is the enemy of reliability. An expression dating back, I've recently discovered, to January, 1958, and The Economist Newspaper.
Looking through this list he is in very august company indeed.
First off, if Linux had a per-unit or similar usage charge, its adoption rate would all but certainly have been vastly lower. Factual basis: the many extant proprietary x86 Unix clones at the time Linux emerged.
There's the question of how to value "use value", and what the value of an OS actually is. Impressions are (IMO deceptively) skewed upward by the example of Microsoft, but it's the rare instance of a software-only mass-market OS platform -- actually, rare to the point of single-instance.
There's the question of what an ordinary or acceptable rate of return ought be.
And there's the question of how much of the returns should be shared with others.
Still, Linux as an enterprise might be compared with, say, IBM or Sun at their peak, possibly HP's server operations. There's the present valuations of Red Hat, Google, and Facebook, among other Internet companies based largely on Linux's capabilities.
Certainly multiples of billions in a traditional sense -- I'd argue for $5 - $20b.
Of course this is kind of speculation on one hand, but there was the Hurd project which might have taken off, or someone else could really have created something similar a year later, if it did not exist.
BSD had it's licensing issues, which today seems more liberating - most programmers seem to embrace it - but in 1992 was seen a free ride license which is something most Linux developers did not like. That's why Linux grew so much,. Saying that FreeBSD would taken that niche seems a little bit off IMHO.
Almost certainly, and also almost certainly FreeBSD. The UNIX Wars did more than anything to ensure that this didn't happen, though.
There's still a bit of an open question. Linux benefited over FreeBSD not only in not having a lawsuit looming over it, but in that its development process was far more open. Though it's arguable that FreeBSD is more stable (and for much of the 1990s had a superior networking stack -- hence its adoption at such shops as Yahoo), ultimately it was the addition of features, and drivers, to Linux which very much ensured its take-off, as well as the numerous distros, each of which had a slightly different focus (and often significantly different package management systems), some of which proved more attractive than others.
I find it interesting that of the two primary x86 unices, the more open one (Linux) beat FreeBSD, and of the Linux distros, a noncommercial and generally open one (Debian and variants) seems to be slowly trouncing the more closed corporate variant (Red Hat).
Around the time Linux was starting to make inroads into businesses. Usually by the backdoor - internal services needed platforms they could install without going through the usual acquisition processes. If it cost money, some beancounter was going to object. (I witnessed a couple of cases first hand.)
So the techies installed some flavour of Linux on decommissioned boxes instead and ran their systems where they could. Individually the cost savings were negligible, but when you suddenly find out that 30 or even 50 internal services are running on top of OS stack that had cost nothing, the upper echelons finally take notice. The fact that the OS could be customised and repurposed for a particular need was an amplifier, and only later became the core "feature".
I recall (with horror) the days when "tweaking the OS" meant running regedit.exe and turning a number of undocumented knobs in directions you could only guess at. Not to mention pray that the system worked on the next boot.
So Linux use began as a way to cut costs (or skip the acquisition process altogether). It ballooned because it was possible to customise and extend the system on the OS level as needed.
• Linux worked. It was "good enough". Once you reached the point of running a shell, GNU userland, an editor, and a compiler, it was off to the races. Not sufficient, but necessary.
• No lawsuit. The UNIX Wars put a multi-year crimp on FreeBSD. The BSD splits didn't help much either (these included not just the userland as in Linux distros, but kernel development --which for Linux distros remains unified).
• Freely hackable, but published changes are licensed under GPL. I don't know how much thought went into Linus's choice of license, but it proved highly fortuitous.
• The time was absolutely ripe. Even within proprietary Unix companies, people were advocating heavily for a freely-available, open-source operating system. See Larry McVoy's "The Sourceware Operating System Proposal", from his days as a SunOS engineer prior to founding BitMover: http://www.landley.net/history/mirror/unix/srcos.html
• Key early adopters and developers. Alan Cox on development, and John "Maddog" Hall at DEC were key in both pushing kernel development, facilitating early ports (to Alpha), and in putting legitimacy behind the effort.
• Multiple distros. Almost immediately a side-light of bundling up the kernel and a set of utilities into a usable package emerged: Boot Root, MCC, TAMU, SLS, Yggdrasil. I remember SLS ("soft landing systems") being explained, somewhat fondly, as "because it was a pile of shit". Eventually over a few months in 1994 Slackware, Red Hat, Debian, SuSE, and Caldera emerged, which with very few notable exceptions continue to rule the distro landscape. I find interesting that "bootable distros" were present from very nearly the start (my own first exposure to these was Linux Root Boot, a/k/a Lnxrtbt, on a single floppy, also Trinux, booting from 2+ disks into a ramdisk). LWN has a good early history: https://lwn.net/Articles/91371/
• As others have noted, functionality, cost, features, and exigency all meant that technical needs felt at the coalface by front-line engineering staff at many firms were being met with decommissioned server, or, very often, desktop systems. While Microsoft-bound CIOs were proclaiming "we run no Linux and never will" their organizations were in fact increasingly not only using, but dependent on it. These denials persisted through the early 2000s, though beyond 1998 or so it was largely only dead-enders maintaining this.
And from there it just continued to build. I'd argue that the linchpin argument wasn't money made selling Linux or Linux services, but companies based on it which simply couldn't exist by other means, of which the most notable early exemplar was almost certainly Google. Running its systems on proprietary Unix or Microsoft platforms would have been prohibitive in both cost and flexibility.
That's a bit redundant.
However, you are right in that the main contributors to the Linux kernel should get a mention in the blurb.
Linux and git have radically changed the face of technology.
"Linus Torvalds, the principal force behind development of the Linux kernel and overseer of open source development for the Linux operating system"
Potato, tomato. No one cares outside of the RMS cult.