As a software developer I, of course, like money being spent on R&D, so the believable answer from me is that just give me most of Your money. However, to other software developers my answer for a single iteration is

**everything_earned_during_the_previous_iteration * sc**

where the

**sc = 0.5 - 1/n**

and the **n** is a positive number that represents "production units", robots, slaves, employees, factories.

That is to say, **according to this idea the optimal investment rate for education-tools-and-R&D approaches 50% when the production capacity approaches positive infinity**. Assumptions behind this model are that no investment is made for increasing the number of production units and that the only change is that the production units become more effective. The rest of this blog post describes, how such a wild number has been obtained.

**The Philosophy**

The set of assumptions has many elements that really do not hold in real life, but the calculation addresses the simplified idea that

**all_work_done_during_one_iteration =
= N_of_work_units *
* sum_of_all_investment_to_R&D_during_all_prior_iterations**

This calculation does not really address the real life situation, but only the simplest form of the philosophical idea that constant investment to R&D is like acceleration to cars and planes and that the vehicles that accelerate the most will get a gigantic win over the more slowly accelerating vehicles. Probably one of the most outrageous simplifications is that R&D results can be bought for money. In real life everybody knows that a truck load of 500€ bills will not get the monkeys in the jungle to get good R&D results, nor does it help to hire more dumb monkeys to speed up the R&D, but, the Master-of-Business-Administration types at mega-corporations, including professional politicians, do not mind violating those rules in practice, so they should not have any criticism about me violating that rule in this calculation. :-D

The designations:

sc --- A real number between 0 and 1 that this calculation tries to find out. The unknown. The "sc" is derived from the word "science". w_sum --- The sum of all work done during all iterations. w_sum_profit_x ---- The sum of all work that is not spent on R&D. That is the variable that needs to be maximized. The sum includes iterations 0..x, including the x'th iteration. n --- Number of production units, robots, slaves, employees. w_x --- work done during iteration x tk_x --- The sum of all R&D investments from the very first iteration till iteration x, including the iteration x. The "tk" is derived from the expression "Tools and Knowledge".

The Initial equations:

**w_1 = tk_0 * n** // work done only during the iteration #1

// The w_sum_profit_1 is the sum of

// all accumulated profit at the end of iteration #1.

**w_sum_profit_1 = w_sum_profit_0 + w_1 * (1-sc)**

// The (1-sc) represents the percentage that is left after the costs of the R&D.

**tk_1 = tk_0 + w_1 * sc** // The accumulation of the R&D investments.

For the sake of simplicity, to allow the process to bootstrap, the **tk_0** is a constant that is greater than 0 and the **w_sum_profit_0=0**. The structure of the solution is inspired by the mathematical induction and is that if the optimal value for the **sc** is found for 2 sequential iterations #1 and #2, then it must be optimal also for iterations X and X+1 and therefore the found optimum value of the **sc** must also be the optimum value for iteration pairs (#2,#3) and (#3,#4) and (#4,#5), etc. because the formulas for those pairs have exactly the same structure that the formulas for the pair (#1,#2) had and if the **sc** has the same value for every pair of sequential iterations in the series of iterations, then it has the same value for the whole series of iterations.

// The formulaes for iteration #1:

**w_1 = tk_0 * n**

**w_sum_profit_1 = w_sum_profit_0 + w_1 * (1-sc)**

**tk_1 = tk_0 + w_1 * sc** // useful only at iteration #2

// The formulaes for iteration #2:

**w_2 = tk_1 * n**

**w_sum_profit_2 = w_sum_profit_1 + w_2 * (1-sc)**

**tk_2 = tk_1 + w_2 * sc** // useless at iteration #2

The next lines convert the formulas of iteration #2 by doing replacements from previous iterations, in this case, from iterations #1 and #0. The idea is that for iteration #X the replacements are applied recursively till only constants and variables from iteration #0 are left at the iteration #X formulas.

**w_2 = tk_1 * n**

tk_1 = tk_0 + w_1 * sc

w_1 = tk_0 * n

w_2 = **tk_1** * n =

= (tk_0 + **w_1** * sc) * n =

= (tk_0 +(tk_0 * n) * sc) * n

w_2=tk_0 *n + tk_0 * n^2 * sc

w_sum_profit_2 = w_sum_profit_1 + w_2 * (1-sc)

w_sum_profit_1 = w_sum_profit_0 + w_1 * (1-sc)

w_sum_profit_1 = w_sum_profit_0 + **w_1** * (1-sc) =

= w_sum_profit_0 + (tk_0 * n) * (1-sc) =

= w_sum_profit_0 + (tk_0 * n) - (tk_0 * n * sc)

w_sum_profit_2 = w_sum_profit_0 + (tk_0 * n) - (tk_0 * n * sc) + w_2 * (1-sc) =

= w_sum_profit_0 + (tk_0 * n) - (tk_0 * n * sc) + (tk_0 *n + tk_0 * n^2 * sc) * (1-sc) =

= w_sum_profit_0 + (tk_0 * n) - (tk_0 * n * sc) + (tk_0 *n + tk_0 * n^2 * sc) - (tk_0 *n + tk_0 * n^2 * sc) * sc =

= w_sum_profit_0 + (tk_0 * n) **- (tk_0 * n * sc)** + (tk_0 * n + tk_0 * n^2 * sc) - **tk_0 * n * sc** - tk_0 * n^2 * sc^2 =

= w_sum_profit_0 + **(tk_0 * n)** - (2 * tk_0 * n * sc) + (**tk_0 * n** + tk_0 * n^2 * sc) - tk_0 * n^2 * sc^2 =

= w_sum_profit_0 + 2 * tk_0 * n - (2 * tk_0 * n * sc) + (tk_0 * n^2 * sc) - tk_0 * n^2 * sc^2

If the **w_sum_profit_2** has any maximums, then they reside where its first derivative by **sc** equals zero.

first_derivative_by_sc(w_sum_profit_2) =

= (-2 * tk_0 * n) + tk_0 * n^2 - 2 * tk_0 * n^2 * sc = 0

(-2 * tk_0 * n) + tk_0 * n^2 = 2 * tk_0 * n^2 * sc

tk_0 * n^2 (-2 * tk_0 * n) = 2 * tk_0 * n^2 * sc

n^2 (-2 * n) = 2 * n^2 * sc

n -2 = 2 * n * sc

1/2 -1/n = sc

**Why am I Thinking About that kind of a Problem?**

I guess that money is also an issue for me, so I have to draw the line, how much do I spend on developing my tools, which is my open source software, learning new things and how much do I spend on looking for clients and doing other kind of work. Of course, life is not that simple, specially in software development, but **I like to know, what the answer would be, if life were that simple**. Besides, I need to understand the perspective of my client candidates, specially, their optimal rate of investment to R&D, even if my understanding of it covers only some extra simplified case. I think that there's still a huge difference between having at least some calculated vision for guidance and having no vision at all.

My personal conclusion of the result is that I should spend about 50% of my time learning new things. My number of "production units" is limited with my brain and unlike in this model, some of the R%D spending does not accumulate, because some of the technology gets outdated, so even if my brain would suggest me less than 50% time spent on learning, the lack of accumulation increases the requirement to learn new things. Another philosophical aspect is that rich, but dumb, monkeys can not achieve some intellectual results that not-so-rich Einsteins can. I'm not an Einstein, but if I just want to get by comfortably and put my efforts on the intellectual realms of things, then being a bit sub-optimal at getting rich is justified. Besides, there is also the limit that how much a person is capable of consuming and whether some resources should be bought at all. For instance, it does not make sense to spend money on gasoline, if cars might just drive on nuclear batteries for free. As little as I know of economics, economists seem to underestimate the disappearance of costs and appearance of totally different opportunities. Just compare the prices of cell phone calls in 2016 and 1990. That kind of leaps can only be achieved by R&D and Einstein was not really that rich. Well, nonetheless I'm almost always in a desperate need for money, regardless of income, so I'm not writing excuses, why I earn, what I earn.

Comments are closed for this post