The first programs were written in binary/hexadecimal, and only later did we invent coding languages to convert between human readable code and binary machine code.

So why can’t we just do the same thing in reverse? I hear a lot about devices from audio streaming to footware rendered useless by abandonware. Couldn’t a very smart person (or AI) just take the existing program and turn it into code?

  • Emily (she/her)@lemmy.blahaj.zone
    link
    fedilink
    arrow-up
    14
    ·
    edit-2
    5 months ago

    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.