So You Want 70 Times Faster Software Automatically?

What does "learn to code" do for white people, and for the white nationalist movement, and supremacists among those nationalists?

For one thing, the guy with the biggest family I ever saw was a professional computer programmer. For a living. Paid for a family of half a dozen kids and growing. Not too shabby.

Most of the work you want to do as a software developer is to add cool new features, or make it work.

Then reality hits. And most of what you're doing in software development is de-bugging the world's buggiest code that breaks all the time.

Unless you have zero ambition and just want to write a standard, boilerplate text adventure game. 

A great and glorious promised land, flowing with code without bugs because it's simple cut-and-paste, redundant, mind-numbing repetition. 

But it's also a land where there's no bugs.

Other places with no bugs: Indoors. Do people like spending time indoors? No. They want to go out. Out is the place they most want to be, even after spending millions of years perfecting the idea of staying in for the night. 

There's just one problem. Want to go out. And that's where all the bugs are.

Why do I care about fixing something nobody wants to spend any time in? The real estate developer and the software developer don't get to enjoy the fruits of their labor. 

They just do the labor. There's wires and studs and a cracked foundation, if you don't know what you're doing. 

In real estate development, it's crystal clear that competent professionals will be required. In softwareland, there's nothing but cracked foundations, and everything's held together with bailing wire.

It takes so long to figure out how to build a company that competently builds a house that you may as well rubber-stamp 100 houses at a time. 

But by the time you know how to build a compenent real estate development company, you may as well rubber-stamp out 100 or companies at a time.

And then pretty soon, you've got a mortgage crisis. 

Software is the wild west. There's no regulations, inspecctions, and men with clipboards insuring the ISO 9001. It's the Wild West of Afghanistan.

You don't dare touch anything. Could be high voltage. It's a problem.

How does this benefit white people and the future of our race?

For now, let's just say it's a great big expensive and therefore lucrative problem that white people are ideally suited to solve.

Starts with building great companies, consolidating software, and then regulating the hell out of the industry before it kills us all.

Because, quite frankly, we don't want to burn through the strategic oil reserves running your Flappy Bird app.

We don't want games turning into yet another communist-controlled propaganda platform to fill up our children with visions of butt plugs.

We want oversight, controls, and  predictability. Investors need oversight, controls, and predictability.

But it starts by showing the world that white Christian men can competently produce meaningful, useful, enjoyable software and software companies better than the next ten thousand developers trying to milk the latest, hottest fad for a quick buck.

The industry is about a hundred years old, and it's got no self-discipline whatsoever.

This goes a lot farther than the existential threat off runaway artificial intelligence.

There have been very few serious-minded attempts to tame this wild beast. The regulations in the Apple Store are a start. But even a company like Apple isn't what it once was.

It feels like it's been artificial intelligence week.

But this isn't about AI, neural networks, genetic programming. Those are merely techniques.

And those techinques get results far beyond what you've told.

Genetic Programming. Why would anyone go to the time and trouble of evolving software? Is it even possible? Isn't it too slow? Wouldn't it take a billion years to get results?



No. Actually, they've got it down to 600 seconds by moving around code like LEGO blocks, which turns a machine's wild-ass guesses into educated guesses.

But once that was fast, they realized the computer was slow at turning this spaghetti code into a final product. Called compiling.

A semi to fully-automated translation step that turns programmer-speak into language the machine understands directly.

Suppose it takes 5 minutes to compile each variation of the program, and you know you'll need at leat 150,000 variations before you can get a reasonable result. Well, that's a lot of minutes. A year and a half.

Maybe you should just hire a professional!

Not so fast. Because it turns out there are clever ways to compile 100 variations at time. No trouble at all. That's a few seconds each. Not so bad.

Now the job is down to 5 or 6 days of the computer's time.

And if that's too long, you can skip the compiling step and evolve the assembly language directly. Which compiles faster, since you're skipping all the slow optimization steps and doing it yourself.

Or you can evolve some candidate individuals written directly in the machine code itself. There may be some trade-offs, but it's a lot faster than 5 days. 

And by applying the same grammatical approach to it, working from a starting point of existing, functional binaries, you're potentially down to a matter of hours of machine time. 

None of which is human time. It's machine time. All of which can be distributed among cloud computers, doing the work in parallel so you don't have to wait very long.

Why would you want to 

Why does Google spend billions of dollars on software engineers? To make a profit.

On average, each competent software developer is worth several times his own salary. There's a shortage of talent.

If you have a mechanical approach that works half the time, that's better than the humans.

And less than 5% of your humans know how to optimize code. They have lots of "reasons" (excuses) why they just won't do it. 

If you're a running a software development company, you've probably spent through thousands or millions of dollars only to find out you've got uncompetitive, frustratingly slow, bloated, memory-hogging, battery-sucking apps clogging up the Google Play store and the Apple Store.

And 80% of your audience has bailed out before the app even finishes downloading.

Meanwhile, 500 million people have downloaded Angry Birds, written overnight, instead of your expensive, high-quality software suite.

To make light, springy, bouncy software go a lot faster without crashing and without bugs, you first have to know what it's doing very slowly, precisely, and correctly.

At some point, you have to laser focus on what it's doing badly. But the talent to do it just doesn't exist.

The payoff is there. Technology is where the money is made. But most of that money goes to the biggest winners. Everyone else gets table scraps.

Which is ok if you like eating someone else's left-overs and being treated like a second-class citizen.

Can't do it without the talent. And like I said, it doesn't exist. Why not?

Because we stopped breeding real programmers in the 80s, and started sending their beige Mulatto butts to commie school to learn gender fluidity and Python instead.

Python! The QuickBasic of our age.



In my beautiful, inspiring recent post, "Make $4 Billion Dollars In Your Spare Time", I proposed a fantastical-sounding, almost science fiction-like way to automatically fix software bugs, which costs about half a percent of the GDP, and secondly, ways to automatically improve the speed, size, or otherwise improve the performance of existing software.

I hadn't proved my point or provided evidence. That would require hyperlinks. (And those take time to copy and paste.)

Sure, you may say I'm a dreamer. But I'm not the only one.

I also mentioned a Brazilian student (now a professor) who built on Dr. Langdon's work to automatically generate and rapidly evaluate code from large datasets. 

He showed his process performs hundreds of times faster than the baseline methodologies by leveraging a high end graphics card to do science, and was able to routinely perform as many as 45 million fitness tests from a population size of about 1.5 billion over the course of 10 experiments.

For comparison purposes, it didn't take 1.5 billion ancient monkeys to arrive at the hairless ape who wrote the complete works of Shakespeare.

If you want to compress multimedia or stream games or get computers to do things they're not supposed to be able to do, elegantly balancing a huge range of trade-offs to arrive at something completely new, genetic programming is likely to give you the mutant freak of high performance you want, but without the bugs.

Or if you have tons of buggy code, and more than 90% of your money is spent on chasing them down and fixing them, automatic bug patching is often an option. 

More automatic bug patching.

https://youtu.be/sRkfMe0_5cA


Even if the bughttps://youtu.be/sRkfMe0_5cA is that it's running too slow, using too much battery, compiles too slowly, the code is bloated with stuf that's never used, and many other cases.

The reason to use the GPU to evaluate the fitness of a proposed solution is because it's very fast at that kind of task, and can evaluate 1,000 or more proposed programs at a time, evaluating them based on 160,000 criteria, and the optimal candidate has to pass all of them millions of times.

In other words, your winner is usually the one that's fastest while performing perfectly. 

A speedup of 70X was created not by generating any code, but simply deleting, inserting, and re-arranging existing lines of code from within the program. 

You can read all about it how this is achieved in A Field Guide to Genetic Programming

This requires a compile step. A computationally expensive one. This is why Da Silva went to the trouble of reverse-engineering the GPU so that he could generate tons of compile-free evolving machine code that runs as close to the bare metal as humanly possible. Impressively ambitious approach to arrive at nothing less than the theoretical ideal for that exact hardware platform.

The result isn't necessarily portable beyond a specific architecture. You can't run machine code optimized for an iPhone on a 386. But with some sort of an emulation step, it should be possible to quickly generate optimized binaries for (within reason) every platform. 

Software written for an Apple Watch won't suddenly be able to find and use the WiFi on a Commodore 64 or Amiga because those things hadn't even been invented yet.

And I somehow doubt the genetic algorithms are going to generate an audio toder you a 

A compiler can spit out hundreds or a thousand variations at a time, but you probably won't reach a family tree of 40 million generations producing over a billion candidate mutations.

Comments

Find a Topic