Not every change is going to completely overhaul the app. More than likely, the changes are a fix to some obscure bug not caught in testing that only affects a small percentage of devices. Just because you don’t encounter it with your workflow and device doesn’t mean it isn’t a critical bug preventing someone from using the app. It could also be a new feature targeting a different use case to yours. It could even be as simple as bringing the app into compliance with new platform requirements or government regulations (which can happen a couple times a year, for example Android often bumps the minimum SDK target such that apps are forced to comply with new privacy improvements).

Just buy a cheap Casio if that’s your budget. It’ll keep better time and is less likely to end up in a landfill

Making a breaking change to the mobile API also breaks old outdated installations of the app. Websites and their APIs are usually synced, apps not so.

If they were really motivated to stop your method, they could just obfuscate the frontend with webpack and break your scraper every time they make an update.

I suspect that any of the methods proposed here would be prone to a C&D, but IMO the safest legally would probably be the RSS method (not a lawyer though). Reddit’s RSS feeds are public, documented, and available without the need for private APIs, authentication, or an API key, so I don’t see how they could claim that a wrapper is unauthorised/illegal. Documenting their private API however seems like a gray area. Google LLC v. Oracle America, Inc. found that APIs are copyrightable, but this use may constitute fair use.

Is there a reason you’re scraping data rather than attaching a network sniffer/reverse engineering the official apps and documenting the results? Or map the RSS feed to an API? The main thrust behind my comment is that I think scraping is pretty fragile, so I’m interested as to why other options are infeasible.

Thank you for adding this! If people want a real life example of the effect shown in this pseudocode, here is a side-by-side comparison of real production code I wrote and it’s decompiled counterpart:

    override fun process(event: MapStateEvent) {
        when(event) {
            is MapStateEvent.LassoButtonClicked -> {
                action(
                    MapStateAction.LassoButtonSelected(false),
                    MapStateAction.Transition(BrowseMapState::class.java)
                )
            }
            is MapStateEvent.SaveSearchClicked -> {
                save(event.name)
            }
            // Propagated from the previous level
            is MapStateEvent.LassoCursorLifted -> {
                load(event.line + event.line.first())
            }
            is MapStateEvent.ClusterClick -> {
                when (val action = ClusterHelper.handleClick(event.cluster)) {
                    is ClusterHelper.Action.OpenBottomDialog ->
                        action(MapStateAction.OpenBottomDialog(action.items))
                    is ClusterHelper.Action.AnimateCamera ->
                        action(MapStateAction.AnimateCamera(action.animation))
                }
            }
            is MapStateEvent.ClusterItemClick -> {
                action(
                    MapStateAction.OpenItem(event.item.proposal)
                )
            }
            else -> {}
        }
    }

decompiled:

    public void c(@l j jVar) {
        L.p(jVar, D.f10724I0);
        if (jVar instanceof j.c) {
            f(new i.h(false), new i.r(c.class, (j) null, 2, (C2498w) null));
        } else if (jVar instanceof j.e) {
            m(((j.e) jVar).f8620a);
        } else if (jVar instanceof j.d) {
            List<LatLng> list = ((j.d) jVar).f8619a;
            j(I.A4(list, I.w2(list)));
        } else if (jVar instanceof j.a) {
            d.a a7 = d.f8573a.a(((j.a) jVar).f8616a);
            if (a7 instanceof d.a.b) {
                f(new i.j(((d.a.b) a7).f8575a));
            } else if (a7 instanceof d.a.C0058a) {
                f(new i.a(((d.a.C0058a) a7).f8574a));
            }
        } else if (jVar instanceof j.b) {
            f(new i.k(((j.b) jVar).f8617a.f11799a));
        }
    }

keep in mind, this was buried in hundreds of unlabeled classes and functions. I was only able to find this in a short amount of time because I have the most intimate knowledge of the code possible, having written it myself.

It’s not impossible, just very labour intensive and difficult. Compiling an abstract, high level language into machine code is not a reversible process. Even though there are already automated tools to “decompile” machine code back to a high level language, there is still a huge amount of information loss as nearly everything that made the code readable in the first place was stripped away in compilation. Comments? Gone. Function names? Gone. Class names? Gone. Type information? Probably also gone.

Working through the decompiled code to bring it back into something readable (and thus something that can be worked with) is not something a lone “very smart person” can do in any reasonable time. It takes likely a team of smart people months of work (if not years) to understand the entire structure, as well as every function and piece of logic in the entire program. Once they’ve done that, they can’t even use their work directly, since to publish reconstructed code is copyright infringement. Instead, they need to write extremely detailed documentation about every aspect of the program, to be handed to another, completely isolated person who will then write a new program based off the logic and APIs detailed in the documentation. Only at that point do they have a legally usable reverse engineered program that they can then distribute or modify as needed.

Doing this kind of reverse engineering takes a huge amount of effort and motivation, something that an app for 350 total sneakers is unlikely to warrant. AI can’t do it either, because they are incapable of the kind of novel deductive reasoning required for the task. Also, the CarThing has actually always been “open-source”, and people have already experimented with flashing custom firmware. You haven’t heard about it because people quickly realised there was no point - the CarThing is too underpowered to do much beyond its original use.

If by conversation you mean asking for a word by describing it conceptually because I can’t remember, every day. If you mean telling it about my day and hobbies, never.

Bundaberg Spiced Ginger Beer

I think the Rabbit R1 is an underbaked and dumb product. That said, Rabbit would have had to have had a few too many kicks to the head if they seriously considered not just running Android under the hood. Android is open source, and there is no good reason to not utilize the hundreds of millions of dollars that Google has already poured into developing mature a mature operating system with all the drivers and frameworks they need.

As a moderator of a couple communities, some basic/copypasta misbehaviour is caught by automated bots that I largely had to bootstrap or heavily modify myself. Near everything else has to be manually reviewed, which obviously isn’t particularly sustainable in the long term.

Improving the situation is a complex issue, since these kinds of tools often require a level of secrecy incompatible with FOSS principles to work effectively. If you publicly publish your model/algorithm for detecting spam, spammers will simply craft their content to avoid it by testing against it. This problem extends to accessing third party tools, such as specialised tools Microsoft and Google provide for identifying and reporting CSAM content to authorities. They are generally unwilling to provision their service to small actors, IMO in an attempt to stop producers themselves testing and manipulating their content to subvert the tool.

The computer is probably locked down and all software/os provisioned by their IT department

This is the comment that tipped the maintainer over the edge:

ayan4m1

You should do a better job updating your documentation so that people do not waste their time like I did. This change to closed source was announced where, exactly? All of your READMEs and documentation sites do not mention this. Very easy to be confused and very disappointing to me that this went closed-source.

Not only did you sell out, you also removed all the old versions that were released under an open source license so that others couldn’t continue to use out-of-support versions. DISGUSTING.

tl;dr get off GitHub and npm entirely if you want to do the closed-source thing, kthx.

Which is incredibly disrespectful in my opinion, and this kind of entitlement is what makes me weary of starting any open source projects.

Seattle and Redmond. So Amazon and Microsoft?

Ok, so functionally reddit points, or a board of editors. Revolutionary.

Are you seriously suggesting that fucking reddit karma is how we should run our news.

Ok, so they do that. Here are some things that can plausibly go wrong:

• Are the people posting the story funding thing anonymous? Because if they are, no one will fund it based on a one line description with no details. If the authors are known, any company engaging in the practice will be watching them like a hawk (essentially making investigation impossible)
• The company engaging in the practice assumes the investigation is aimed at them and temporarily stops double billing until the journalists runs out of budget and everything blows over. They then resume double billing.
• The company engaging in the practice assumes the investigation is aimed at them and consequently intimidates would-be whistleblowers into staying silent, basically preventing any progress
• The company intentionally floods “Kickstarter for News” with spurious stories to drown out the item about them
• The story isn’t funded because it doesn’t agree with the preconceived notion of enough users, who are only willing to fund content matching their own worldview
• The story isn’t funded because, while people find it is important, more attention was placed on a story that agreed with the preconceived notion of enough users
• What stories are funded have a huge bias towards the material condition of the wealthy (moreso than now), since they are the only ones with enough disposable income to fund content. Therefore, content focused on the conditions of the poor and marginalised is ironically marginalised
• Unable to be subsidized by less prestigious entertainment content (like traditional investigative journalism was), the required upfront cost for stories balloons to a size not feasibly collected by donations
• The wider population becomes apathetic to the platform as a whole (people have actual jobs and lives, and may not have the time to trawl through potential stories for something they want to fund), leaving only the extremely wealthy/powerful to fund stories. As a consequence the media is even more controlled by the elite than it is currently
• It turns out there was never a story, and those that donated feel burned and are less likely to donate in the future
• It turns out there was never a story, and, feeling pressure to produce something, the journalists intentionally misconstrue the truth

I think a crowdsourced approach is a great idea, but only in the sense that my tax dollars go to independent news organisations.

That seems like a terrible idea. How are you supposed to properly investigate a story if you have to first disclose the entire lead to the world? Would this not create the same kind of overreaching editorialism that investigative journalists already push against, except now the person doing the editorialising is actually a whole pool of donors?

I am

Never? I wouldn’t tolerate it and wouldn’t work at a place that did