Joe, could you use the very simple approach shown below?

In[1]:= array = Table[i, {i, 960000}];

In[2]:= Take[array, {425, 429}]

Out[2]= {425, 426, 427, 428, 429}

In[3]:= array[[427]] = x

Out[3]= x

In[4]:= Take[array, {425, 429}]

Out[4]= {425, 426, x, 428, 429}

In less time than it took me to figure out that render[] (in addition to AddX[]) needs a HoldFirst, I installed Python, learned Python, and finished my program in Python.

In[1]:= SetAttributes[addX, HoldFirst]

In[2]:= addX[monoBuffer_] := monoBuffer[[2]] += x

In[3]:= (*With[{monoBuffer=Range[5]},addX[monoBuffer];monoBuffer]*)

In[4]:= Module[{monoBuffer = Range[5]}, addX[monoBuffer]; monoBuffer]

Out[4]= {1, 2 + x, 3, 4, 5}

In[5]:= render[monoBuffer_] := addX[monoBuffer]

In[6]:= Module[{monoBuffer = Range[5]}, render[monoBuffer]]

During evaluation of In[6]:= Set::setps: {1,2,3,4,5} in the part assignment is not a symbol.

Out[6]= 2 + x

In[7]:= SetAttributes[render, HoldFirst]

In[8]:= Module[{monoBuffer = Range[5]}, render[monoBuffer]]

Out[8]= 2 + x

For symbolically calculating integrals, Mathematica is helpful; for solving equations, it's helpful if you lucky enough to phrase your question in a way Mathematica understands; but for digital-signal-processing, Mathematica is a hindrance. There are too many free alternatives that don't require you to run experiments, trial-and-error, and jump through hoops in order to simply pass an array by reference. These free languages---e.g., C, Common Lisp, Python---are thoroughly defined by their respective language-specs; Wolfram Language is vaguely described by its docs, and the rest is left to the user to figure out through trial-and-error or asking questions on forums.

I'm really not sure why you would introduce those Modules there, you don't need them.

That is what I first assumed too, but if you replace "Module" with "With", as I had in my initial attempts, you will get additional errors. I found my way to "Module" only through trial-and-error, divide-and-conquer, and other time-consuming and frustrating debugging methods.

Why I need any scoping construct there at all is because my actual code is more like this:

Module[{monoBuffer = Range[5]},
 render[monoBuffer];
 <do various things to monoBuffer after it's been processed by render[]>]

C, and Lisp are both, by default, call by value, one has to do work to pass by reference.

That's not true of C-arrays or Lisp-lists (in Common Lisp). The only thing passed by value is a pointer to the head of the array/list. The body of the array or list is effectively passed by reference.

(setq testList (list 1 2 3 4))
(defun modifyList (list) (rplaca (nthcdr 2 list) 9))
(modifyList testList)
testList
(1 2 9 4)

you still haven't told us what you want to do

because certain details are irrelevant and not public information.

This thread seems kinda useless if it just you complaining about something that you don't fully understand because you have not studied it very well yet...

I'm explaining why I won't be investing further in Mathematica. As a fan, you have the luxury of digging your feet in, blaming everything on the users, and defending shortcomings in a program you apparently worship; but for the developers running a business and wondering why there will be one less customer returning, I'm offering helpful information.

I have studied what I'm doing well enough to have coded parts of the world's 1st commercial software synthesizer.

When I want to integrate symbolically, I will use Mathematica, not any other language. Symbolic was manipulation was a primary reason for trying/buying Mathematica, and it's good for that. That was the original emphasis in 1987, if I understand correctly. Now that it's grown, though, and they have an entire chapter in the docs titled "Sound", they could enhance the design or at least the docs to make it easier to pass massive arrays around?

And yes, Python took me only a few hours to learn, but that's because I've already spent years doing C/C++.

If you don't want to write Unevaluated every time, you can also set HoldFirst once:

SetAttributes[add7To2ndElement, HoldFirst]
add7To2ndElement[list_] := list[[2]] += 7

Module[{list = {1, 2, 3}}, add7To2ndElement[list]; list]

Basically (roughly?) += (the function called AddTo) does the following:

x = x + dx

so in your example that translates to:

2 = 2 + 7

However you can't set '2' to something! it's not a symbol!

When you use set (=) the left hand side has to be a symbol; it can't be a number or string or ...

I'm not sure what you mean 'without using any named variables', do you mean that the function also excepts lists (not symbols):

add7To2ndElement[list_] := Module[{out = list}, out[[2]] += 7; out]
add7To2ndElement[{1, 2, 3, 4}]

Or do you mean it does not have any intermediate named variables:

add7To2ndElementAnonymous = ReplacePart[#, 2 -> #[[2]] + 7] &
add7To2ndElementAnonymous[{1, 2, 3, 4}]

Both return {1, 9, 3, 4}...

Nearly all functions make copies of the inputs, modify it somehow, and return a new list, not explicitly overwriting your variables, exceptions are:

AppendTo
PrependTo
AssociateTo
KeyDropFrom
AddTo
SubtractFrom
TimesBy
DivideBy
(Pre)Increment
(Pre)Decrement

These will update the first argument (a symbol) and will also return something. Not creating copies. Note that they have a 'To' , 'From' or "By" et cetera at the end to distinguish them from:

Append
Prepend
KeyDrop
Add (Plus!)
Subtract
Times
Divide

which all create new lists.

That is why you have construct like HoldFirst, HoldAll, UnEvaluated et cetera, so you can pass it on 'by reference' (a la pointer) rather than 'by value'. The function I mentioned above demand all have the first argument 'HoldFirst', and they work pointer-like.

But please come with a concrete (yet simplified) examples, rather than these hypothetical ones that display your problem.

Function does not have HoldFirst, it will pass on the values 'by value'. So buffer[[2]] = will be some number on the left hand side, spawning the error. ReplacePart does not change 'buffer'. It will create a copy of buffer and return the modified version of it.

When you return something it will automatically be a copy (I'm pretty sure about this), But that is not necessary:

SetAttributes[f, HoldFirst]
f[x_] := (x[[2]] += 7;)

testing:

a = Range[5]
f[a]
a

{1, 2, 3, 4, 5}
{1, 9, 3, 4, 5}

applying f to a will modify a, the function returns Null, but a is modified.

O btw, I think Octave is also mostly (like Matlab) 'pass by value'; making copies everywhere.