News for hackers. Stuff that matters.
Re:Don't tug on that, you never know what it might be attach... by userbinator on Friday July 01, 2016 @07:21PM (#12020400)
Great debugging, and an example of the sort of behaviour that long dependency chains can expose.

Or rather, I did until this week, when it suddenly stopped working.

When this happens to me, the first thing that I ask myself is "what changed?", and I'm usually able to track down the cause to some configuration change. Incidentally, this is also why I never like modifying a working system unless it's absolutely necessary.

The fact that it ultimately was caused by some security features that would be very important for a multiuser shared server but nearly irrelevant for the (presumably) single-user local machine that he is using suggests that perhaps we shouldn't be thinking of "one size fits all" paradigm for OSs, since a lot of problems like this one stem from the unnecessary extra complexity introduced by such thinking.

Re:Don't tug on that, you never know what it might be attach... by cantrevealname on Friday July 01, 2016 @08:13PM (#12020671)
> Incidentally, this is also why I never like modifying a working system unless it's absolutely necessary.

It's why I find auto-updating apps so infuriating. The trend is that every app, OS, and driver insists on being self-updating. It's going to be very difficult to maintain a reliable system if you're doing anything complex.

Privacy issues aside, that's another reason I never plan to use the continuously self-updating Windows 10.

Re:Don't tug on that, you never know what it might be attach... by groby_b on Friday July 01, 2016 @08:57PM (#12020876)
On the other hand, chasing after CVEs is also infuriating, but in the opposite direction. auto-update makes it possible to live in an environment where security issues are found by the bucket load every day.

There really isn't a good answer either way, but between "breaks occasionally" and "needs a full-time admin, but updates are vetted", I prefer option 1 for my private systems, and option 2 for things that run in production.

Re:Don't tug on that, you never know what it might be attach... by dozzie on Saturday July 02, 2016 @02:46AM (#12021655)
This is where supported distributions come in. In Debian or Red Hat you can practically assume that the OS update will not break anything. (There are occasions where it does break something, but I don't remember anything major in a good few years.)
Re:Don't tug on that, you never know what it might be attach... by AznHisoka on Friday July 01, 2016 @08:40PM (#12020817)
I hate apps that do 1 job and do it extremely well and it insists I update just so I am on the latest version. It works now stop bugging me. I don't care if you changed the color scheme!
Re:Don't tug on that, you never know what it might be attach... by stephengillie on Friday July 01, 2016 @09:21PM (#12020945)
A benefit to web apps is seamless updating to users. One click loads the updated webpage. They might not even notice their profile pic has changed from square to round!
Re:Don't tug on that, you never know what it might be attach... by TeMPOraL on Saturday July 02, 2016 @06:49AM (#12022080)
Today you reload and see nicer buttons; tomorrow you reload and see them thanking you for the incredible journey you went on together that leaves them with new jobs and $hittons of cash, and you with a search for a new tool.
Re:Don't tug on that, you never know what it might be attach... by mynewtb on Saturday July 02, 2016 @06:30AM (#12022040)
That often is not a benefit for the users though and one of the reasons why I only use 'web apps' for throwaway work.
Re:Don't tug on that, you never know what it might be attach... by dozzie on Saturday July 02, 2016 @02:48AM (#12021658)
...and then good luck when the application that yesterday worked well today doesn't work at all, because somebody removed a small function critical to your workflow and you can't get it back. Seamless experience!
Re:Don't tug on that, you never know what it might be attach... by digi_owl on Saturday July 02, 2016 @08:06AM (#12022196)
The basic problem there is the mixing of feature changes and security changes in a single stream.

So you can't just say you want security fixes only, no new or changed features.

Re:Don't tug on that, you never know what it might be attach... by btilly on Saturday July 02, 2016 @11:59AM (#12022951)
The problem with trying to separate them is that often a security fix is put into code that had feature changes, and so you can't get the security fix without the feature changes.

Going the other way requires developers to maintain a variety of old versions of their code so they can backport security changes. Which is a lot of work for them for very little extra value.

Re:Don't tug on that, you never know what it might be attach... by dredmorbius on Saturday July 02, 2016 @01:35PM (#12023211)
Hence Debian's practice of back-porting security fixes on stable distros.

Also applies to Ubuntu, probably Red Hat, though the latter's vastly smaller repos mean vastly greater reliance on third-party sources, and concommitant risks of introducing/changing features when security fixes are wanted, or riding bareback without security updates.

There's also the inherent conflict between running current code and fixed code. Debian's legendary conservatism reflects a bias toward the latter, at least on its stable branches. Of course, you're welcome to lead and bleed on testing, unstable, or experimental, if you so choose.

Re:Don't tug on that, you never know what it might be attach... by digi_owl on Saturday July 02, 2016 @12:44PM (#12023057)
IOW you can't get a developer to do straight maintenance work...
Re:Don't tug on that, you never know what it might be attach... by Bartweiss on Friday July 01, 2016 @11:45PM (#12021293)
I think this is a serious issue, at least for developers. I've never been burned by a self-updating browser, but anything beyond that seems downright unacceptable. There are just too many fragile, hand-managed dependency chains at work even in good setups.
Re:Don't tug on that, you never know what it might be attach... by greenyoda on Saturday July 02, 2016 @12:34AM (#12021382)
"I've never been burned by a self-updating browser..."

I develop browser-based software which, after one Chrome update, was rendered unusable by a bug in Chrome. Fortunately, Google pushed out a new version with a fix the next day.

Re:Don't tug on that, you never know what it might be attach... by Bartweiss on Sunday July 03, 2016 @06:10PM (#12027865)
I did suspect that "I've never been burned" just meant I hadn't developed enough for browsers...

This also seems like a good reminder that transparent updating only works if your team is good and responsive enough to fix mistakes on the fly. If you're rolling out one update a month, you'd better give people a choice so they can decline when you hand them faulty upgrades.

Re:Don't tug on that, you never know what it might be attach... by gohrt on Friday July 01, 2016 @07:28PM (#12020431)
> this is also why I never like modifying a working system unless it's absolutely necessary.

this is safe, but it paints you into a corner over time, where you become paralyzed and can't improve anything. Needs better testing, so changes are safe.

Re:Don't tug on that, you never know what it might be attach... by jsankey on Friday July 01, 2016 @11:18PM (#12021230)
Exactly. It's analogous to the difference between big bang integration and continuous integration. The lesson there is: if something hurts, do it more often. Little steps let you know exactly what changed when something breaks.
Re:Don't tug on that, you never know what it might be attach... by xyience on Friday July 01, 2016 @07:35PM (#12020465)
Tests don't magically make changes safe or give the confidence to make changes.
Re:Don't tug on that, you never know what it might be attach... by vacri on Friday July 01, 2016 @09:14PM (#12020922)
A culture of many small changes means that you deal with smaller problems relatively quickly. The more you fall behind, the bigger the jump to where you should be, and it's not a linear relationship.

At one place where I work, we're on nodejs 0.10, which is several release versions behind. It's causing us a bunch of problems, because while 0.10 is still technically not EOL'd yet, npm modules behave like it is... however we've left it so long, that the jump to current stable is a giant task, which we don't have the time for given other business reqs.

Tests indeed don't guarantee safety, but lots of small changes are easier to deal with than the occasional massive change. It's also the basic concept behind version control.

Re:Don't tug on that, you never know what it might be attach... by Osiris on Sunday July 03, 2016 @02:01AM (#12024980)
This is my experience as well with node and shrinkwrap. I see people using shrinkwrap to avoid potential issues, but what ends up happening is they get stuck on old versions of dependencies and when there's a bug fix or new feature that's needed it can be very difficult to upgrade. Instead, I prefer to try to always keep my dependencies up to date, especially with new major versions to avoid exactly this problem.
Re:Don't tug on that, you never know what it might be attach... by tamana on Friday July 01, 2016 @09:06PM (#12020904)
No, they scientifically make changes safe and give confidence to make changes.
Re:Don't tug on that, you never know what it might be attach... by TeMPOraL on Saturday July 02, 2016 @06:56AM (#12022094)
Do you think that, in case of the problem from this article, Perl devs should have had a test checking if their update doesn't break someone's Emacs when they try to use it in client-server mode, launching one via a Perl script and other via some other means, on a Linux with "capabilities" feature?

This story wasn't about trivial day-to-day developer bugs, but what kind of problems happen in really complex systems.

Re:Don't tug on that, you never know what it might be attach... by xoa on Friday July 01, 2016 @10:29PM (#12021115)
>this is safe, but it paints you into a corner over time, where you become paralyzed and can't improve anything.

As someone who went through the process of a painful, long delayed upgrade not too long ago I definitely second this, although as a much more generalized principle I think it'd be more accurate to say that there's a fine, eternal balancing act between "work" and "meta work", and that this principle applies to way more areas of life then systems work. However much fun (or "fun") it may be, as mjd said there most/all of us primarily have work to do using our tools ("tools" being in the most generic sense here, including knowledge) rather then working on our tools. To some extent, a few days spent on tools/skills is a few days not spent applying them, and it's all too easy to sink so much time going down various rabbit holes that "actual work" loses out. But of course on the flip side improving our tools/skill sets is key to realizing major boosts in long term productivity, keeping up with changing standards, and so on. I remember a few years back at one workplace when a number of senior engineers (50s/60s) all finally bit the bullet and started to work to get up to speed on the latest CAD developments. Or myself a decade back when I decided I really needed to update my shell usage, read the full ZSH manual and spend some time seeing how I could improve my speed in general. There were many significant projects going on, but then there always were, always something that "needs to be done next week!". I personally find it can be a tough balancing act to optimize the savings gained from increased productivity down the road vs the time expenditure needed to begin realizing them in the first place, particularly if "everything is working fine". I know that over the years I cumulatively lost plenty of time on manual involvement in tasks I could have automated, but each individualized instance seemed trivial and it was easy to default to just hacking something quick and getting on with the day vs deciding it'd be worth spending time to improve it for good.

Of course that's all assuming there aren't any other barriers in the way. My extremely oddball pain point on one workstation was that I'd enthusiastically built an tower Mac Pro OS X system around ZEVO, an short lived attempt to salvage Apple's old ZFS work and bring a fully functioning version to OS X. And despite a few niggles (some which didn't matter to me, like CLI-only), by the time it was getting ready to go it was fantastic, nicely integrated and all that. I was pumped, it was exactly what I'd wanted under OS X ever since I'd seen Sun's original presentation, and I hopped fully onboard. But of course the company developing it promptly went under just as they were launching, were bought for IP/people by GreenBytes (which itself was subsequently acquired by Oracle), and after a single bug release that was it. It only worked under 10.8 and not one version later, and there was no clear upgrade path (I really didn't want to revert that system back to pure HFS). So 10.8 was where I stayed until OpenZFS and in turn O3X came along to save the day, but by that point I was out of the habit of frequent upgrades there. Testing is definitely helpful (along with a nice rollback system) but sadly can't always save you, frequent upgrades definitely help keep key meta-knowledge fresh.

This was a really cool bug track down article though, and inspiring.