Emily (she/her)

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

Isn’t that what “classic” confinement is supposed to solve?

I contribute and run some open source projects. Some projects receive sponsorships and contributions, some are backed by companies, a lot are just someone doing it on their own time, very few can actually meaningfully support the people working on them. Personally, I receive no money for mine.

After a certain point, learning to code (in the context of application development) becomes less about the lines of code themselves and more about structure and design. In my experience, LLMs can spit out well formatted and reasonably functional short code snippets, with the caveate that it sometimes misunderstands you or if you’re writing ui code, makes very strange decisions (since it has no special/visual reasoning).

Anyone a year or two of practice can write mostly clean code like an LLM. But most codebases are longer than 100 lines long, and your job is to structure that program and introduce patterns to make it maintainable. LLMs can’t do that, and only you can (and you can’t skip learning to code to just get on to architecture and patterns)

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.

Do you have a data feed to pull from, or some kind of list of matches? It shouldn’t be too hard to use a simple python script to parse a file and post automatically on a schedule. I maintain a repo that doesn’t exactly match your use case, but I could maybe add your functionality depending on complexity

Bundaberg Spiced Ginger Beer

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.

Just use Kotlin

I am

I’ve gotten all my friends hooked on OpenTTD multiple separate times

Don’t get into business with a narcissist. If you don’t figure out they’re a narcissist until after the business has started, bail or kick em out.

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

Likewise, an open source project can totally die if they refuse to engage with the needs of the users. The lack of moderation and content management tools have been a longstanding criticism of Lemmy, and instances will migrate to alternatives that address these concerns. It is a genuine legal liability for instance operators if they are unable to sufficiently delete CSAM/illegal content or comply with EU regulations.

Mine accurately describes me

But was the code they wrote substantially identical to yours? Was what they claimed credit for your work just modified, or did they write an entirely new port that only bears resemblance?

If its the latter, you got the exact amount of credit you deserved. I’m not going to argue that their conduct was professional (though, neither was yours), but they don’t have any obligation to credit you further.

deleted by creator