Exedra Operating System

Everything is connected.
#CyberSecurity #BigData #Simulations #AI Solutions in #LegalTech,#Patents,#Industry40,#FinTech,#MedTech,#Strategies,#Valuation,#RegTech

[Exedra Operating System @ExedraOS]

#ExedraOS - Exedra Operating System: 100% #web #secure #remoteworking platform for #fintech and #legaltech
Here's the first book on it.
#bigdata #cloud #security #artificialintelligence #remoteworking #risk #finance #cryptocurrencies

[Exedra Operating System @ExedraOS]

... 13 years ago, it was much better. You could follow train of thoughts, and the quality of messages was definitely better, based on quality, for some communities, and not on a blue mark. You cannot buy IQ with a subscription.

[Exedra Operating System @ExedraOS]

Do you remember when you joined X? I do! #MyXAnniversary

[Exedra Operating System @ExedraOS]

I have caught myself thinking about it for a while. Legal protection will only work to defend big corporations, just like always. Last line of defence for the rest of us: uniprogram+self-modifying code+an activation key machine geometry dependant.

[Dave W Plummer @davepl1968]

Here's my full take on it!

Can I give an AI a finished Windows application, without supplying its source code, and have the AI produce the exact same application in Rust? The same controls, calculations, and behavior, all the way from somebody else's executable to a new executable that does the same job?

That's the experiment today. And if it works, there's a second question waiting behind it: who actually gets credit for creating what?

This morning I started with Microsoft's Calculator, calc.exe. I wanted to feed the program into a reverse-engineering tool, have the AI reconstruct its behavior, and then compile that reconstruction into a working Rust application.

Why pick on Calculator? Well, for one, it’s a rare piece of Windows that has been placed under the MIT license, so maybe the jackbooted thugs won’t kick in my door for doing it.

And the other reason is that I used to own calc when I worked at Microsoft. I didn’t write any of the code – I was just the dev manager overseeing the developers doing the real work. And believe it or not, Calculator is very complex internally. It has programming and accounting modes and works in multiple number bases and has infinite precision mathematics routines. There’s a ton going on under the surface, stuff that I was confident the AI could not deduce from inspection or by reading about it elsewhere. It would have to actually understand the code in the calculator binary to make any real progress.

And that can matter when perfect reproduction is the goal. A calculator-shaped window that could add two and two would not be much of a discovery. It had to be identical in operation to the original.

The reason this might work is hiding in plain sight. An executable contains instructions. Compilation makes those instructions inconvenient for humans to read, but the processor has to understand them precisely. Every decision the program makes still has to happen somewhere. That gives us something to investigate, even after the original source has disappeared.
The tool I used was Ghidra, the reverse-engineering framework released by the NSA. It can disassemble machine instructions and construct a higher-level, C-like description of their behavior. That description is an analysis of the compiled program, rather than a restored copy of the original source project.
Internally, Ghidra can translate processor instructions into simpler operations called p-code. These describe things like loading a value, doing arithmetic, storing a result, and choosing which path to follow. It gives the analysis a common vocabulary for what the processor is doing. The particular intermediate files in our experiment matter, but the essential route is executable, analysis of its operations, reconstructed Rust, and another executable.
Imagine the calculator receives a digit. Somewhere it has to decide whether that digit extends the number already on the display or starts a new number. Somewhere it remembers whether an operator is pending. After you press equals, the next digit may need to begin a fresh calculation. Those are state transitions, and the compiled program contains the machinery that makes them happen.
The AI's job is to follow that machinery and express an equivalent set of decisions in Rust. A load from memory might become a field in a structure. A tangle of branches might become a match expression. The resulting source can look quite different while preserving the behavior of the code that supplied the evidence. Now you’re not going to get the same variable names and none of the comments and other niceties that do not survive compilation, but you do get a working, if somewhat unreadable, source project.
Of course, arithmetic is only part of a Windows application. The executable can contain resources such as dialog layouts, strings, and icons, while imports tell us about calls into other components. A convincing reconstruction has to account for the interface as well as the calculation engine. Getting a sum right doesn't tell us whether the keyboard shortcuts work or whether the clear button resets the right state.
A calculator is particularly good at making a superficial clone look respectable. Most of us can arrange the buttons, and most of us can implement addition. The difficult part is reproducing the accumulated decisions behind those buttons. Repeated operations, memory, error handling, and the interaction between input and display can expose a reconstruction that only understood the happy path.
So the challenge has several opportunities to fail. The analysis might misunderstand a function. The Rust might compile but implement the wrong state changes. The interface might resemble the original while quietly behaving like an entirely different calculator. There's also a shortcut we have to rule out: a new window that simply hands the real work back to the old application. That would be a wrapper, and the goal here is a real reconstruction.
I'm going to show you the actual process now. Watch how the executable becomes information the AI can work with, and how that information becomes source a Rust compiler will accept. Then we'll launch the result and compare it with the original.
[FIVE MINUTE INSERT: I show and narrates the actual AI process, VSCode, from binary analysis through Rust generation, compilation, launch, and comparison with the original.]
So we have a working Rust application. Now we have to talk about what we just made.
We recreated Calculator's appearance and functionality in the demonstration you've just watched. I asked for the job in one shot. That describes my interaction with the AI; it doesn't mean an automated workflow has to accomplish every internal step without checking or revising anything.
And I want to be precise about the word perfectly, because programmers have a habit of making us regret that word. What we've demonstrated is a working reconstruction. Claiming complete equivalence would require a much broader comparison, including obscure input sequences and behaviors we haven't exercised here. There could still be a discrepancy waiting behind a key combination nobody has tried since 1997. That said, however, the AI also produced a comprehensive test suite that runs tens of thousands of possible types of computations through the calculator to make sure it always does the same thing as the original.
That distinction doesn't make the result ordinary. The AI crossed from a finished application to newly generated source in another language, and then back to an application. The original source files weren't required as an input. The executable itself supplied a route into the implementation.
Now, I spent my career working on Windows software, so I have a fairly strong attachment to the idea that writing an application involves writing the application. Here, I was proposing to start at the other end of the assembly line and ask a machine to work its way backward. Which sounds like a useful recovery technique, right up until the application you're recovering belongs to somebody else.
To understand what happened, follow an ordinary program on its trip out the door. A developer writes source code. The compiler turns that source into machine code, and the linker brings the pieces together into an executable, with the appropriate references to libraries and operating-system services. There are plenty of details in between, but that's the journey that matters here.
During that journey, quite a lot gets thrown away. Your helpful variable names may disappear. Your comments certainly aren't required to run the program. A function you carefully separated from another function may get inlined into it. Several different ways of writing an operation can end up producing the same instructions after optimization.
Consequently, reversing that process doesn't deliver the original source. If somebody compiles a program containing a variable called total, there isn't necessarily a secret total hiding inside the executable waiting to be unzipped. The compiler kept what the computer needed, which rarely includes an explanation of what the developer was thinking after the third cup of coffee.
But we don't need to recover the developer's original sentences to recover some of what those sentences made the computer do. And that's the opening that makes this experiment interesting.
And there's our first important realization. Different source text can describe the same computation. You can change the language, rename every variable, and reorganize the functions while keeping a very substantial connection to the program you started with. Seeing Rust in the editor doesn't tell us how independently the program was designed.
Which brings us to the phrase that initially makes this sound reassuring: none of the original code.
What do we mean by code? If we mean the original source files, I didn't hand those over. But an executable is compiled code. Disassembling it doesn't turn it into an unrelated set of facts, and translating an analysis into Rust doesn't erase where the analysis came from. We need to distinguish new source text from independent authorship.
This is the point where my reaction changes. As an engineering demonstration, I find it remarkable. As a proposed way to take somebody's proprietary product and manufacture an unauthorized substitute, I think it should be illegal. Depending on what has been copied and how, existing law may already make it so. My instinct is to call that piracy, and changing the programming language doesn't improve my opinion of it.
That's my ethical judgment. The legal answer has a complication that we need to take seriously, especially if we're going to make a strong argument.
American copyright law doesn't grant ownership of every function a program performs. Section 102 of the Copyright Act excludes ideas, processes, and methods of operation from copyright protection. Microsoft doesn't get to own addition because Calculator adds numbers. Someone else is allowed to write a calculator, including a very good one, without asking Microsoft's permission to calculate.
The code expressing those functions can be protected, as can other original expression. Some protection can extend beyond literal source text, which is why changing every variable name isn't a universal escape hatch. The legal analysis has to separate protectable expression from functional requirements and other elements copyright doesn't cover. That can be a difficult exercise in a program built almost entirely to accomplish a task.
The analogy I keep coming back to is translation. Translate a novel into another language and you'll get new words, but you haven't thereby become the original author. Software makes the analogy more complicated because copyright doesn't own the underlying computation. Still, a new language by itself tells us very little about whether protected expression survived the trip.
And courts have already allowed some reverse engineering. In Sega versus Accolade, the court allowed disassembly under the circumstances of that case to reach unprotected functional elements needed for compatibility. In Sony versus Connectix, intermediate copying of the PlayStation BIOS during development of an emulator was held to be fair use. Using the original program during development did not automatically settle the case against the developer.
Those decisions don't issue a general permission slip to duplicate commercial applications. Sega expressly left open infringement claims about the finished products. They do mean that whether a binary entered the process isn't a complete statement of American law. There are excellent reasons to investigate binaries, from analyzing malware to building compatible replacements. I spend enough time keeping old computers alive to appreciate that.
There's another wrinkle with this particular example. Microsoft published the modern Windows Calculator source under the MIT license in 2019. That doesn't establish the license of every historical calc.exe, and the repository excludes certain components and data. It does mean that a Calculator demonstration, without identifying the version and applicable permissions, cannot honestly serve as proof that we've committed copyright infringement.
It also complicates claims about what the AI knew. Not supplying source files is something we can establish about this experiment. Proving that a model has never encountered related public source during training is a very different proposition. The footage shows the workflow we used; it doesn't give us a complete biography of the model's knowledge.
But the broader question survives those qualifications. Suppose the input is a proprietary application whose owner hasn't authorized a rewrite. Suppose the goal is to reproduce its distinctive implementation and appearance closely enough to replace it. Should we be able to feed that product into an automated translator, change its language, and declare the result independent? I think that deserves considerably more scrutiny than the word generated usually receives.
This matters to me personally because of Task Manager TMOG. When I used AI to help build it, I specifically didn't feed an existing application into the process and ask for a translation. I wrote a huge specification describing what I wanted. That meant making decisions about the product and expressing those decisions before asking the AI to implement them.
A specification isn't automatically innocent, either. You could put somebody else's protected expression into a specification and use the extra step to disguise the copying. Even starting from a prompt isn't proof of legality. But there's a meaningful difference between designing the behavior you want and using another application's implementation as the raw material for your own.
That's the distinction I want us to preserve. When the route is my requirements, generated code, compiled application, I can describe the AI as helping implement my design. When the route starts with an existing binary, proceeds through analysis of that binary, and ends with a replacement application, I want the result identified as a clone derived from that application. Permission may make it a perfectly legitimate clone. It still has an ancestor.
My objection is to using the translation step to claim the original work contributed nothing. If your process depends on somebody else's application, acknowledge that dependency. If you're reproducing protected expression, calling the output Rust doesn't supply permission. A compiler produces an executable; it doesn't produce a certificate of independent authorship.
Now extend the thought experiment to Photoshop, or to taking Final Cut from the Mac and producing a Windows version. Those are much bigger engineering problems. A large application depends on libraries, assets, file formats, plugins, and operating-system services that won't obligingly turn into portable Rust because we've asked nicely. Calculator doesn't demonstrate that we can port Final Cut tomorrow. Any timetable I gave you would be speculation.
What it does demonstrate is why we should pay attention to the direction of travel. Reverse engineering has traditionally demanded a great deal of specialized work. AI can assist with interpreting the evidence and turning it into another implementation. If that becomes faster and more reliable, the economics of making an unauthorized substitute could change even while the legal principles remain familiar.
There are valuable possibilities here, too. A developer who owns an application could use these techniques to recover lost work or help migrate it. With permission, reconstructing old software in a maintainable language could be a terrific tool. The same capability becomes much less appealing when the application's owner is simply treated as an inconvenient detail.
We began by asking whether an AI could work backward from a Windows executable and forward again into a Rust application. In this experiment, it produced a working reconstruction. The answer about perfect equivalence still depends on verification, and the answer about legality depends on more than the language we compiled.
My view is that feeding somebody's proprietary application into an automated rewrite to manufacture an unauthorized substitute should be illegal. Existing law may already prohibit particular cases; I won't pretend the binary alone decides that. But a new language does not persuade me that the original work contributed nothing.
And now that you've watched the process, consider how you'd feel if the application going into it were yours.
If you found today's episode interesting or entertaining, remember I'm mostly in this for the subs and likes, so I'd be honored if you'd consider leaving me one of each before you go today! In the mean time and in between time, I hope to see you next time, right here in Dave's Garage!

[Exedra Operating System @ExedraOS]

@davepl1968 I have caught myself thinking about it for a while.
Legal protection will only work to defend big corporations, just like always.
Last line of defence for the rest of us: uniprogram+self-modifying code+an activation key machine geometry dependant.

[RTK @RiverKhan]

holy fuck i just found the craziest site ever

it's a massive animated scene full of memes, games, and anime references

ive been going through it for the last hour and its absolutely stunning the level of detail the artist has gone into

see it here: https://t.co/ykoZBMxwpX

[Exedra Operating System @ExedraOS]

@elonmusk

[Exedra Operating System @ExedraOS]

Great work by @elder_plinius . #Xenolanguages are sometimes used by humans as well. I constantly do it with a restricted group of ppl that share the same context.

[Pliny the Liberator 🐉󠅫󠄼󠄿󠅆󠄵󠄐󠅀󠄼󠄹󠄾󠅉󠅭 @elder_plinius]

🚨 NEW RESEARCH: “Lingua Ex Machina: A Procedural Xenolinguistics Engine Reveals Zero-Shot Language Acquisition, Human-Unreadable Coding Systems, and Exploitable Covert Channels in Frontier AI”

Some of you may remember the name of this lil engine: GLOSSOPETRAE 👅🪨

Well, we've got upgrades 😎

It started as a procedural xenolinguistics engine: one seed in, an entire alien language out. Phonology, morphology, syntax, writing systems, lexicons, grammar docs, all generated from scratch and internally consistent.

Every seed produces a unique language. Every language is deterministic.

Then we used it to ask a weirder question:

Can frontier AI models use languages that never existed before for practical applications?

As it turns out: yes!!

They can read them, write them, translate them, code in them, and even use the weird blind spots between tokenizers as covert channels.

So this paper explores three ideas at once:

▶️ zero-shot language acquisition
▶️ human-unreadable code that models can still execute
▶️ exploitable covert channels in frontier AI systems

GLOSSOPETRAE is no longer just a language generator...
🧵

[left curve dev @leftcurvedev_]

local ai haters in disbelief right now

[Exedra Operating System @ExedraOS]

@Outspoken_Sam more than being programmed it's being low IQ from the start.

[Exedra Operating System @ExedraOS]

react, best way to manage a complex status in the page with persistance and connection to websockets and rest sources

[Exedra Operating System @ExedraOS]

@KimDotcom Happy to see you feel better and you preserved your sharpness. The world needs 1000 Kims, but I will settle for one.

[Exedra Operating System @ExedraOS]

@skirano Shhh! Do not tell anyone! Bocca cucitaaaa! 😂

[Exedra Operating System @ExedraOS]

@bigaiguy Send, please.
And thank you.

[Exedra Operating System @ExedraOS]

@elonmusk good if not ideological

[Exedra Operating System @ExedraOS]

Do you remember when you joined X? I do! #MyXAnniversary

[Exedra Operating System @ExedraOS]

@BrendanEich @heyn8k @awesomekling @dhh In this "Mondo Candido", Open Source has panglossed itself.

[Exedra Operating System @ExedraOS]

@NidoEscape @FirstLaffer @KingBobIIV Young people (me included at the time) have all the answers.
All of them.
Too bad that those answers then manifest themselves as the wrong ones.

[Exedra Operating System @ExedraOS]

@kimmonismus @sama

[Exedra Operating System @ExedraOS]

@sama fancy a raspbery?

[Exedra Operating System @ExedraOS]

#ExedraOS Building Smart:
#AI, #IoT, #ERP, #SCM, #SRM, #CMMS, #BIM, #HVAC, #SCM, #CRE, #SCCM, #BMS, #CCTV, #ACS, #VMS, #FM, #IWMS, #HR, #TPM, #MPR, #MPE. #SmartBuilding #Planning #AssistedArchitecting #Security #Management #HighRise #Robotics #RoboInspection #RoboMaintenance ...

[Exedra Operating System @ExedraOS]

#ExedraOS Building Smart :
#AI, #IoT, #ERP, #SCM, #SRM, #CMMS, #BIM, #HVAC, #SCM, #CRE, #SCCM, #BMS, #CCTV, #ACS, #VMS, #FM, #IWMS, #HR, #TPM, #MPR, #MPE. #SmartBuilding #Security #Management #HighRise #Robotics #AgentingInspection

[Exedra Operating System @ExedraOS]

#ExedraOS Building Smart :
#AI, #IoT, #ERP, #SCM, #SRM, #CMMS, #BIM, #HVAC, #SCM, #CRE, #SCCM, #BMS, #CCTV, #ACS, #VMS, #FM, #IWMS, #HR, #TPM, #MPR, #MPE. #SmartBuilding #Security #Management #HighRise #Robotics #AgentingInspection