I want to fix programming

What if you created a declarative language which allows you to override the algorithms in a functional/imperative? You could create a public algorithm repo that auto-pulls into your local machine on setup. Could search for algorithms by declarations. That would be a lot of reuse.

You already said you will be looking and SQL closer, so let me give a few pointers here.

Consider that in SQL you specif how to store data, including indexes, and then what you wan to get, but not how to get it. In other words you specify data structures and the engine picks a set of algorithms and builds an execution plan. The next logical step would be for the user to specify the schema, while the database engine is not only choosing algorithms but also reshapes your data into data structures that would allow optimal algorithm selection later on. At first it would only build new indexes, but then it could also start employing partitioning and ultimately move to normalization/denormalization.

Secondly, be on the looklout for when a problem reminds you of a SQL query. For example, a mail application looks like a query where you specify which fields from which emails you want to see and in what order, and on top of that query result you're specifying a style sheet, CSS on steroids, to make it render pretty. Style sheet is also declarative, not imperative! I am presently working on a framework that follows this model to facilitate iPhone app development, and it's looking pretty good already.

See Nile/Gezira: http://www.vpri.org/pdf/tr2009016_steps09.pdf

Also, the STEPS project in general (read the progress reports): http://www.vpri.org/html/writings.php

They talk about "active" or "runnable" maths. The programming languages they create aim to basically mirror mathematical expressions. This in turn makes the programming stack much smaller and easier to comprehend.

That function definition is a monstrosity because it is poorly factored. Assuming pre-existing fromBase and toBase functions, here is a definition that in my opinion is easily readable and matches your verbal description:

    halton b n = fromBase b (reverse digits) / b^(length digits)
        where digits = toBase b n

Just to show there's nothing up my sleeve, here are the fromBase and toBase definitions:

    toBase b 0 = []
    toBase b n = (n `mod` b) : toBase b (n `div` b)

    fromBase b []     = 0
    fromBase b (n:ns) = n + b * fromBase b ns

They too read like how a mathematician would define them. (I abstained from use of foldr/unfoldr to make this clear.)

Edit: On second thought, it's easy to implement it as a direct recursion. I'll demonstrate it in C so I'm not accused of language chauvinism:

    double halton(int b, int n)
    {
	return (n == 0) ? 0.0 : (n % b + halton(b, n / b)) / b;
    }

Here the digit reversal is implicit in the recursion (the oldest programmer trick in the book).

This C code is self-contained and compiles to a tiny handful of machine code instructions, so it's hard to see how your statement that "this simple 1-line equation in math becomes hundreds of thousands of loops in practice" holds much water.

that's actually not that far from what programming with well-designed libraries and abstractions is like now. at least, I know I have a more-or-less 3d visualization of my program in my head as I'm working on it... but that could be just me.