Some states have laws that gift cards never expire, like California. A lot of companies will just go with the most strict rule, rather than micromanaging state by state. The side effect of this is the company "keeps" the money that isn't spent. It may be earmarked at gift card money, but it will never be spent.
I am terrible at spending gift cards. I have some that are from 2007, 18 years old. Two years ago I decided I should check them all and actually spend them. Of the dozen or so cards (several of them for Apple), only 2 of them had an issue, all the others were still active with the original balance.
One of the issues was easily solved, it was a Visa gift card that had an expiration date... I reached out to the company and they issued a new card with an extended date. The other seemed to be so old that the underlying company was sold and pivoted, and changed systems (I assume multiple times) along the way. What was a card for a local restaurant chain now seemed dedicated to Dick's Sporting Goods... at least that's where the phone number went. I haven't yet tried going to the actual restaurant to see what happens.
This reminded me I did an awful job of actually spending them. I guess I need to try again.
The project is a mix of licenses since it's a mix of components. If I had to guess, they intend source code and maybe the binaries under GPLv3 that they own, fonts under SIL Open Font, but "brushes" and "splash images" under CC_BY_NC, etc. mean they could probably constrain certain uses:
Our Paint is a painting application.
Copyright (C) 2022-2025 Wu Yiming
Learn more about LaGUI: https://ChengduLittleA.com/lagui
Support the development: https://patreon.com/ChengduLittleA
Our Paint is licensed with GNU GPL v3, and Noto fonts are licensed with SIL Open Font license. You should be able to find details about the license in the source code directory.
The splash screen images under Resources are licensed with Creative Commons Attribution-NonCommercial 2.0 Generic (CC BY-NC 2.0). You can not use these images commercially, but you are free to contact the author for licensing info on other products such as prints.
The brushe files packed with Our Paint distribustion are licensed with Creative Commons Attribution-NonCommercial 2.0 Generic (CC BY-NC 2.0).
My personal opinion is that if that's what they intended, it seems quite reasonable.
> there's a built-in assumption that no commercial entity would _want_ to use it under GPLv3 terms.
We also have a fairly strict no GPL dependency at work which I find surprising. Especially for a software like this one that you only use, never ship nor modify I don't understand the risks this license poses. It's like we went from a reasonable "be careful around it" to a "don't touch it with a 10 foot pole". And it's leaving me wondering if there is a more concerted effort to demonize this license
- Other GPL software can just include features in my programs if they wanted to.
- I can remove myself from the responsibilities of potential free maintenance burden if approached by commercial entities.
- On paper it prevent crappy Chinese companies here from taking the code as their own (which is unlikely judging by the nature of this program, but if they want they probably would do it anyway just like the case with ffmpeg).
I tried to like OCaml for a few years. The things that hold me back the most are niggling things that are largely solved in more "modern" langs, the biggest being the inability to "print" arbitrary objects.
There are ppx things that can automatically derive "to string" functions, but it's a bit of effort to set up, it's not as nice to use as what's available in Rust, and it can't handle things like Set and Map types without extra work, e.g. [1] (from 2021 so situation may have changed).
Compare to golang, where you can just use "%v" and related format strings to print nearly anything with zero effort.
Go's %v leaves a lot to be desired, even when using %+#v to print even more info. I wish there was a format string to deeply traverse into pointers. Currently I have to import go-spew for that, which is a huge annoyance.
Python does it best from what I've seen so far, with its __repr__ method.
The default %v does leave some to be desired, but don't underestimate the utility of being able to shove anything at it and get something back. This is especially important because this applies recursively; you can have a structure that may have something "unprintable" buried deeply in it, but at least it won't prevent you from printing everything else.
Strongly-typed languages that do not force any sort of stringification on values, and thus refuse to compile if you try to dump a simple log message of one of these values out, are really annoying to work with. I understand the conceptual purity of saying "Hey, maybe not everything even has a string representation" but it makes debugging a real pain. If I were writing a new language today I think I'd mandate that everything gets a default debugging string output by default because the alternative is just so rough.
Even a not-great printer that may have a sort of "*unprintable*" bailout, or print something not terribly useful, but doesn't actually stop you from printing anything, is better than a language that completely rejects it at compile time.
> Scavenger is a cool arcade/thinking game very much like Lode Runner. You've got to run around and collect objects while avoiding enemies. Some objects are buried and you've got to dig down to get at them. It's an addictive game and some of the levels are devilishly (cruelly) complicated to solve.
Heh, I use pass like this; but it's on my (Pine)Phone, so it doesn't solve the parent's original problem ;-)
Although the nice thing about CLI workflows is that I can easily run it by SSHing into my phone (just make sure you set up GPG so the passphrase prompt will appear in your terminal, and not as a popup on the phone!)
> How do you as a method author opt in to distinguishing between [break and next] after yielding to a block?
I don't use Ruby much lately, but if I yield to a block which calls break, control will pass to the code following the block (and not back to my method). If the block calls next or simply finishes, control passes back to me though I cannot know if next was called or not (but do I care? I can go ahead and yield the next element of a collection either way)
> But I can't even close an open file handle after a break.
Yes, you can. That's what ensure (the Ruby equivalent of "finally") is for. Or, better using File.open with a block where you do the work, which uses ensure under the hood.
Yes you can, you use a finally clause around your call to yield, as you would already do to handle possible exceptions happening in the block. So no extra consideration is needed.
This paper, "Insufficient Sun Exposure Has Become a Real Public Health Problem" [1] states "thus, serum 25(OH)D as an indicator of vitamin D status may be a proxy for and not a mediator of beneficial effects of sun exposure".
That is, while vitamin D can be used to deduce someone's amount of sun exposure, the benefits of sun exposure are not coming from the vitamin D.
I'm not an expert here, but this is not generally true. See "giftcard escheatment laws". I think these vary by state, but see e.g. https://legalclarity.org/when-do-gift-cards-become-subject-t... The value of abandoned cards goes to the state.
reply