• 0 Posts
  • 15 Comments
Joined 1 year ago
cake
Cake day: June 20th, 2023

help-circle



  • Kinda. IANAL, but here’s my understanding: If you’re explicitly dual-licensing and publish the proprietary license then contributions can be assumed to also follow the same dual licensing. You’d need to be extremely careful with writing the proprietary license though, since your business is now using non-employee proprietary code.

    If you write “the copyright holder may choose to allow an entity to use this work”, then you do actually need permission from every contributor. If you write “this work may be copied, modified and redistributed freely by Blah enterprises” now the business cannot be sold without losing access (or possibly have it’s name changed). If you write “Neshura may freely copy, modify and redistribute this” then you can’t be fired or move jobs without the company losing access.

    You can also never ever change this license, since every contributor needs to agree. So if a mistake is made when writing it you’re just fucked.

    On the other hand with a CLA that transfers copyright ownership you don’t need to dual-license at all since everything already belongs to the business. Much less risky.









  • I can see how you might come to that conclusion, but porting to 64bit is way more involved than it may seem. x86-64 is different enough to x86 that you’re basically porting to a new architecture: all your assembly will break just like it would porting to arm. On top of that all your sizes have changed and caused all sorts of bugs, for instance: long is 4 bytes under 32 bit on all platforms, but it’s 8 bytes on macOS & Linux and 4 bytes on Windows under 64 bit.




  • __dev@lemmy.worldtoMildly Infuriating@lemmy.worldTable Flip Time 🙃
    link
    fedilink
    English
    arrow-up
    4
    arrow-down
    2
    ·
    1 year ago

    This is plainly false. Hash collisions aren’t more likely for longer passwords and there’s no guarantee there aren’t collisions for inputs smaller than the hash size. The way secure hashing algorithms avoid collisions is by making them astronomically unlikely and that doesn’t change for longer inputs.