12 ms·
What other gifts continue to be the responsibility of the giver after they're given? If I give you a puppy, and it gets sick, should the vet bill me? If I gav
by h2odragon 5y ago
What other gifts continue to be the responsibility of the giver after they're given?
If I give you a puppy, and it gets sick, should the vet bill me?
If I gave you a car, and the wheels fall off two years later, is that my problem?
In this instance people have been using this Java package for years I gather without problems. Why is the responsibility for changing the package anyone but theirs, the people using it; now that they're decided they have stricter requirements for that need?
Even the entertainment industry's notion of "ownership" isn't so endless. They'd like to be paid every time we use their product, but have settled for "licensed media" ... but that license doesn't extend to replacing the media when it wears out.
- dasil003 5y agoThis cultural expectation follows naturally from the nature of software. Software (especially of the networked variety) isn't something you can just deploy and be done. It has to be maintained to continue running over time as the ecosystem changes. The cost of this maintenance is lowest when amortized across the largest set of users, hence the success of open source software, and the desire to avoid forks. The people who are most qualified to maintain software are the original creators, so that is the path of least resistance. Of course no one is obligated to maintain anything, open source maintainers abandon stuff all the time without any repercussions beyond passive internet rage.
- andrewflnr 5y agoYep. The puppy analogy falls apart when you've given the same puppy to 10,000 people. All of them could pay the vet bill separately, but we instinctively recoil from that as being horribly inefficient (and personally inconvenient) when it's possible for just the one puppy-giver to pay it.
- daniel-cussen 5y ago> If I give you a puppy, and it gets sick, should the vet bill me? > If I gave you a car, and the wheels fall off two years later, is that my problem? So in Western culture there's this notion that a gift creates no further obligations. The recipient should just be happy he got what he got and not expect anything more. As if to say, at least you didn't get nothing, you can still get nothing, you want nothing? I would say with the puppy if it gets sick and the recipient can't afford it, you should accept paying the bill. Before it was the "giftee's" puppy, it was your puppy for some small amount of time after you got it and before you gave it. Surely when you gave me a puppy you expected me to be able to keep it alive, right? And as for the car, it's not right to give someone a car whose maintenance they can't afford. The puppy and the car are two excellent examples of gifts that cannot be given without forming a relationship between the giver and the receiver. On the other hand a gift you can give and split and that's it is food or money. Just handing money to a beggar, he might ask for more, and you can walk. In some African cultures it's more like, if you do me a favor, do me another favor, and then we're true blue and you can rely on me to help you in return, but never in a tit-for-tat manner. It's in the book Debt: The First 5000 Years.
- georgebarnett 5y agoThe software library in question wasn’t gifted. It was made open/available for re-use from a library. The person who chose to put it into _their_ code took ownership of its ongoing maintenance in their instance of its usage (presumably because they felt that would be less work than entirely diy). There is no puppy here.
- pas 5y agoIt's prudent to decline a gift if one doesn't really have the circumstance to accept it responsibly. As in the case of a puppy. Or an offered position. (Eg. if someone shows up at your doorstep and gifts you a military rank and accepting that would make people to expect you to go and lead them in battle.) But a car is not a liability. They can sell it. It won't "go bad like a puppy" if it just sits in a garage.
- daniel-cussen 5y agoA car is a liability. And it does go bad if it sits in the garage, the tires, the battery dies...Plus the space it takes up. Maybe if you didn't have that car in your garage you could do something interesting with that garage, like form Hewlett-Packard or Apple? I expect there wasn't a car in those garages. So it takes up space, about the same as what you need to house someone, and if you want to sell it you I suppose have to drive it...no I guess you're right in that regard, you can show it to people until you sell it. But it's better to regift it, so you're not responsible for harm that could come from bad condition, in fact come to think if there's no trust it might itself be a regift. Yeah, it's a liability.
- aflag 5y agoWorst case scenario, you can throw the car away. You had no car before receiving it as a gift, you'll be not worse off if you throw it away. The dog is a little worse because you may become attached and in general, you can't really treat animals like objects in our society.
- 5y ago
- xorcist 5y agoThe examples are a bit one sided. If I give you covid, is that my responsibility? If I give you a piece of software with a backdoor in it, is that my problem? In reality, all actions carry various kinds of responsibilities. And well designed backdoors looks exactly like oversights, so the difference isn't all that clear cut in pratice.
- deleted 5y ago[deleted]
- kelnos 5y agoI mean, it depends? If you give me covid, and you did so intentionally or negligently (as in, you knew you had it and yet did not isolate or at least tell me you have it so I can decide not to meet with you), then yes, that absolutely is your responsibility. But if you contracted covid from a trip to the grocery store, were asymptomatic, had no idea you had it, and I got it from you, I certainly wouldn't hold you responsible. The software-with-backdoor bit is similar. Did you put the backdoor there, and then give me the software with the intent to later use the backdoor against me? That may not be your "problem", but it's certainly your responsibility. Or did a contributor sneak a backdoor into the software, but, despite your best efforts, you missed it? I'd be upset, and might trust your technical judgment less, but I would hold the contributor responsible, not you. > In reality, all actions carry various kinds of responsibilities. Yeah. Going back to the covid example, I could imagine an intermediate situation where you didn't know you were infected, but for the past months you'd been engaging in all sorts of risky behaviors: not getting vaccinated, no social distancing, no masking in crowded indoor places, hanging out with unvaccinated people in close quarters, etc., then I'm probably not going to react as severely as if you deliberately gave it to me, or knew you had it and didn't warn me, but I'm certainly not going to hold you blameless either.
- rapind 5y agoI think it could be both a user and an industry issue. Lately I’ve been experimenting with treating many libraries as a starting point in some of my projects. Meaning I read and use the code, often removing things I don’t need. So I fork and maintain my own lesser / crippled version (and hope authors don’t take this as passive aggressive criticism!). This helps me lower attack surface and better understand what’s going on. This doesn’t work for everything obviously. I’m not forking an OS or database, so there are still lots of black boxes, but for some stuff for I’m liking this approach. Now if another dev inherits my code I doubt they’ll see it my way. The industry wisdom points at simply assembling libraries and only writing your specific business logic. So what if you use a library to do one thing that just happens to do 100 other things (this having a much larger attack surface and bug potential)? I don’t know yet if I’m being foolish or if I’ve stumbled on some ancient programmer wisdom I simply failed to grasp earlier. At least I’ll probably never run into a leftpad issue.
- FridgeSeal 5y ago> So what if you use a library to do one thing that just happens to do 100 other things (this having a much larger attack surface and bug potential)? I’ve wondered about this for a while, and one idea that’s crossed my mind is whether compiler stages could be introduced to do this. For example, you add a dependency, you use a few methods and structures. You compile it, the compiler goes through your code, looks at what traits, implementations, etc that you do and don’t use, it grabs just the code required to satisfy these, and proceeds as normal. At the end it spits out a little report for you telling you what specific things it included/excluded from your binary/library. Like tree-shaking in JS but better. Maybe this already happens during dead-code-elimination passes, or during some other compiler step, maybe most of our libraries are far too interconnected/non-modular to be able to do this without ending up with the whole dependency anyway, maybe it’s computationally infeasible due to some result in Computer Science, I don’t know-and wouldn’t really know where to look to find out-but if it could be done, and if we could go even further to embed this metadata into the resulting binary itself, we’d at least have a provable way of saying “my application is safe from x because it does not include <vulnerable part of lib y>”. I imagine to do this, you’d need to operate on source code-unless there’s some magic way to do it with precompiled binaries-and runtime dynamism would make things extra difficult, but it’s an interesting idea.
- deleted 5y ago[deleted]
- shadowgovt 5y ago> Why is the responsibility for changing the package anyone but theirs, the people using it; now that they're decided they have stricter requirements for that need? It isn't. Every open source consumer is ultimately responsible for the use of the code. That's baked into every open source license I'm aware of. Even the "share and enjoy" mantra is a tongue-in-cheek reference to a rhyme that ends with recommending what porcine orifices you can put your head on if you don't like the software. ... But there's more to be gained by the original authors, in glory and internet points, by publishing a fix for the problem than in washing their hands of the whole affair. Some people want their code correct as a point of professional pride alone.
- xg15 5y agoIt's not just internet points, it's what makes the whole thing practically viable. If you don't give any guarantees beside "it's a hobby project", you can't expect anyone else to use your software beyond hobby projects either.
- ekidd 5y ago> If you don't give any guarantees beside "it's a hobby project", you can't expect anyone else to use your software beyond hobby projects either. I am happy to provide consulting services and support guarantees through my LLC, and have done so in the past. Non-paying users who ask nicely might get fixes. Or they might not! Unfortunately, those fixes might also arrive a year or two after they stopped caring, I'm sad to say. But a project which doesn't bring me any revenue, and which doesn't function as valuable advertising, is only going to receive support when I have the time and the inclination. Realistically, commerical adoption is only interesting to me if there's some upside for me. This isn't to say that companies should never use my libraries or tools. Just that if they want timely support, they should be prepared to either pay me, or use the "Fork" button.
- nomdep 5y agoReviewing code is (should be) significant less work than reimplementing it yourself, if you were able to do it in the first place.
- xg15 5y ago> In this instance people have been using this Java package for years I gather without problems. Why is the responsibility for changing the package anyone but theirs, the people using it; now that they're decided they have stricter requirements for that need? Because for a long time, libraries have been advertised as building blocks that you can quickly integrate into your own application without having to understand in detail how the library works. This assumption has been pretty crucial in the cost/benefits calculation for using libraries vs writing functionality yourself. Now that internet security is becoming an ever more serious topic, this assumption might be less and less viable to hold. We've walked back on it to an extend already with the current best practice of "you don't have to understand how it works, but at least update frequently". However, it might as well happen that this is not enough to keep security issues from happening. Things are already moving in a direction where it's absolutely expected that a developer understands and takes responsibility for every line of code that is included in their prodiuct, whether they wrote it themself or not. But if that happens, it will fundamentally change the way we deal with libraries and how software ecosystems work. Yes, free software devs can smugly repeat their stance of "it's a gift so don't complain, no guarantees about anything" - but if everyone took this serious, no one could use free software for anything critical, so the free software movement would be mostly dead. > now that they're decided they have stricter requirements for that need? I think what made the log4j vulnerability so dangerous wasn't the ability to load arbitrary code via JNDI on it's own (even though that was certainly a horribly overengeneered and dangerous feature). The main vulnerability was that log4j was accepting substitution patterns in the "parameters" section of a logging command, the main purpose of which is to accept untrusted input. There has been at least one other CVE which exploits this without needing JNDI at all. "Don't trust user input" hass been a fundamental rule of security for a long time, and it was reasonable to assume the log4j authors were aware of it. So the current situation is not that requirements have suddenly became stricter, it's simply that log4j broke a fundamental assumption about its API. (I'm also pretty sure that while the JNDI thing was an unfortunate feature and was "working as intended", the "substitutions in untrusted input" part was likely a honest bug and never intended like that)
- 908B64B197 5y ago> However, it might as well happen that this is not enough to keep security issues from happening. Things are already moving in a direction where it's absolutely expected that a developer understands and takes responsibility for every line of code that is included in their prodiuct, whether they wrote it themself or not. But if that happens, it will fundamentally change the way we deal with libraries and how software ecosystems work. That's one of the differences between coders and engineers. Coders just import libraries to avoid re-inventing the wheel. Engineers consider each import as a dependency they'll have to maintain, buy support for or replace. Log4j just highlighted this difference, with some knowing exactly what to patch and others franctically trying to determine if one of the thousands of dependencies they imported into their app actually used it. > Yes, free software devs can smugly repeat their stance of "it's a gift so don't complain, no guarantees about anything" - but if everyone took this serious, no one could use free software for anything critical, so the free software movement would be mostly dead. There's a simple alternative: hire the devs.
- netcan 5y agoSo... this is essentially a cultural question, so I think the best way to look at it is empirically. Not exactly your question, but there's an anthropological pattern whereby gift exchange between individuals of disparate class or power (eg peasant & lord) automatically create a tradition. If a boss gives his employees a turkey for christmas, christmas turkeys become a permanent expectation. If a lord give his king 20 camels for spring equinox, this can easily escalate into a permanent tax.
- hinkley 5y agoI know a former software developer who is very open about going to therapy. He once commented on this fact, saying that he knew someone who also talked openly about therapy, and that he never would have gone if they hadn't known this person. Essentially he's hoping to be 'that guy' for somebody else. Computer science, to people who are picking college degrees, seems like a safe, sterile environment of pure logic. But the only jobs are in software development, which is organic as hell. It's messy, it often smells, sometimes it rots. And sometimes it's just scary. A lot of people seem to be in denial about this for a long time. Software is full of social capital and emotions, and we often try to conceal both behind a mask of objective thought. I can tell you ten logical reasons we shouldn't write the code this way but the real problem is that I think your solution is going to leave me stressed out of my comfort zone and/or missing life events because I either can't trust that you'll clean up your own mess, or that the business won't let you because you can't do it fast or robust enough. So I'm gonna argue with you about getting anywhere near that cliff edge, but we're not going to talk about the proverbial agoraphobia because that's too hard. And if my logical, objective, sterile reasons for saying 'no' are deflected, odds are very good I'm going to acquiesce instead of actually agree, and I'll be secretly stressed, possibly grumpy, possibly even ready with an 'I told you so.' All while we're trying to keep hard things 'professional'. Your solution is nerve wracking. This one is not. We should use this one, because we have better things to stress about. You're goddamned right we're going to trade a little more stress for you now for less stress for the entire company three months from now. It's a fair trade.
- stevenhuang 5y ago