The first time I recall hearing the idea of using “tried-and-true” technology aka OLD tech was when someone described Nintendo’s approach to hardware. After about a decade of experience I catch myself often saying that I prefer to have my stack to have a patina.
As a young engineer I kind of laughed at this idea because of course I knew everything and wanted to use the latest and greatest always. I wanted speed, I wanted new, I wanted it all.
Cutting Edge
Sometimes there is no choice, you must access a new feature or API endpoint that requires something new. Often time it is a choice though. The risk I think is high. It has to be worth it.
Ok so some more AI gen:
If you would like to join my “Generative AI Group Chat” drop me a note in one of the many forms on this site.
A “Brain Trust” refers to the collective intelligence and knowledge contained within a group or team in a company or organization. This valuable resource often consists of tribal knowledge, which is the information and expertise that is shared through informal channels and passed down from experienced members. By tapping into this Brain Trust, organizations can foster innovation, improve decision-making, and enhance overall performance. Encouraging open communication, collaboration, and continuous learning can help harness the power of a company’s Brain Trust and ensure that its tribal knowledge is preserved, shared, and leveraged to drive success.
or with a slightly different prompt
A Brain Trust is an informal group of experts who provide advice and insights to an individual or organization. The term was popularized during the Roosevelt administration, where a group of advisers, known as the “Brain Trust,” provided guidance on various policy matters.
Mixtral24
Primary Knowledge
Some people have knowledge that is not easily acquired through a typical or obvious learning process. They were there, they built it, they know why it was built that way. They understand the constraints, the tradeoffs, the baggage & luggage.
Tribal
Sometimes this knowledge is guarded. Not even in in secret internal wiki. Never written down. Why would you write it down? If you have nobody to share it with, why write it down. Enter the new age of auto-transcriptions. If you aren’t transcribing all your internal meetings into a curated corpus, you are being blocked by legal. or you are missing out.
Some will be actively hostile to sharing. Need to know lists (N2K) create vast arrays of silos of information. They may not be allowed to tell you.
Back to techno optimism.
I think we are just back to having secretaries
commandpattern.org – on LLMs and GenAI
Examples of Tribal Knowledge
Where the Water Main master shutoff valve is
…
Brain Trust as a Service. I think the only two companies you are competing against right now is Google and Microsoft. Good luck.
What are the consequences of this tribal knowledge concept in your organization?
I think it maybe clear that you could think of this in the Malcom Gladwell’s metric, one line of code for one hour. It actually seems reasonable. I remember reading an article about Billy G’s company that average Microsoft programmer added about 10 lines of code a day to codebase.
It seems painfully slow. Obviously, yes, you can sling code quicker than this. But average it out over lifetime of project. Code writing is minimal. You spend most of your time on marketing and support, at least you should. This being said, 10,000 lines of code can do a lot, but as you approach this number the structure could get harder to extend and add features/fixes.
Legacy
Some people look down on this piece of language. I love legacy codebases, they often make me the most money. They are easier to maintain and keep in production*. Rewriting in the latest trend is very uninteresting to me. Normally legacy projects have hit that wall already they are on rewrite number 4. (the best big number release of any software?)
Lines of code (LoC) may be the only true measurement of code I can reason about… It is arbitrary and subjective but it is a metric. This magic number of 10k LoC is somewhat historic and perhaps it should be adjusted based on language and style of application. It takes 2 lines to declare and set a variable in some variants of BASIC for instance. This is a 2x in line count for really nothing.
What happens when you are in the ballpark of this many lines of code? You start to have a mess! Unfortunately the garden must be pruned and rearchitected and this gets harder and harder as you approach this level of code mass.
It’s a UNIX system! I know this
Jurassic Park
UNIX
Famously the original Unix source from Ritchie and Thompson cloc’s in at about 10k LoC. They had some assembly in there as well. I’d think if you can fit an entire operating system into that small of a codebase surely we can do more with less these days.
Codebases are divided into two sections: Luggage & Baggage. Luggage is what you need and baggage is because of what the state of the world you are building upon..
I learned to program in the 1990s when terms like Object Oriented Programming (OOP) and Rapid Application Development (RAD) were where people thought the future was headed. The exact way I “learned” C++ was through a yellow “learn c++ in 24 hours”
I guess I got the title wrong, it was yellow for sure:
I quit programming after about 3-4 months with this book. I remember they taught OOP through making terminal GUIs for DOS. I went back to Photoshop4 and decided I wasn’t smart enough.
Perhaps teaching OOP to a BASIC programmer with mid 90s C++ is what ruined me.
Main Topic
Leaving behind the baggage, let’s discuss what Object Oriented Programming is:
Objects are like people. They’re living, breathing things that have knowledge inside them about how to do things and have memory inside them so they can remember things. And rather than interacting with them at a very low level, you interact with them at a very high level of abstraction, like we’re doing right here
I tell you what, that sounds great, but also terrifying. I think his quote actually shows a deep understanding of what Objects or “Classes” are in and the consequences in OOP.
Functions
Lets look at my Ray Tracer Challenge starting point for primitives:
import math
EPSILON = 1e-6 # [0-1] - grid size or fidelity (smaller is, is smaller)
tuple4 = tuple[float,float,float,float] #vector t[3]=0, point t[3]=1
# this can be replaced with math.isclose()
def float_is_equal(a:float, b:float, eps=EPSILON)->bool:
return math.fabs(a-b) < eps
def tuple_is_equal(a:tuple4, b:tuple4, eps=EPSILON)->bool:
return \
float_is_equal(a[0], b[0], eps) and \
float_is_equal(a[1], b[1], eps) and \
float_is_equal(a[2], b[2], eps) and \
float_is_equal(a[3], b[3], eps)
def tuple_neg(a:tuple4)->tuple4:
return (-a[0], -a[1], -a[2], -a[3])
def tuple_add(a:tuple4,b:tuple4)->tuple4:
return (a[0]+b[0], a[1]+b[1], a[2]+b[2], a[3]+b[3])
def tuple_sub(a:tuple4,b:tuple4)->tuple4:
return (a[0]-b[0], a[1]-b[1], a[2]-b[2], a[3]-b[3])
def tuple_is_point(tuple:tuple4)->bool:
return int(tuple[-1]) == 1
def get_vector(x:float,y:float,z:float)->tuple4:
return (x,y,z,0)
def get_point(x:float,y:float,z:float)->tuple4:
return (x,y,z,1)
Ok lets try and use this:
Its not bad, but when we start adding more features to tuple it may become harder for a reasonable person to clearly see how to use this Application Programming Interface (API) for your tuple4 type.
Towards an Object
As you can see when you start down this path, the implementation can get annoying to program against. You could, with a small penalty performance wise*, wrap this functional interface in an object.
Lets motivate this a bit by looking at this code here:
import prim1 as pr
import canvas_io as cvi
ball_pos = pr.get_point(1,1,0)
#ball_vel = pr.tuple_norm(pr.tuple_mul_scale(pr.get_vector(1,1,0), 1.25))
ball_vel = pr.get_vector(15,15,0)
env_gravity = pr.get_vector(0,-1,0)
#env_wind = pr.get_vector(-0.01,0,0)
env_wind = pr.get_vector(0,0,0)
def tick(ball_pos, ball_vel, env_gravity, env_wind):
return (pr.tuple_add(ball_pos,ball_vel), pr.tuple_add(pr.tuple_add(ball_vel,env_gravity),env_wind))
def sim(ball_pos, ball_vel, max_iters=1e3):
pos_t = []
for t in range(int(max_iters)):
ball_pos, ball_vel = tick(ball_pos,ball_vel,env_gravity, env_wind)
pos_t.append(ball_pos)
if (ball_pos[1] <= 0):
print('ball hit ground')
break
return pos_t
pos = sim(ball_pos,ball_vel)
canvas = cvi.get_canvas(900,550)
for p in pos:
x = int(p[0])
y = int(550-p[1]) #swap y axis
#y = int(p[1])
cvi.canvas_write_pixel(canvas, x, y, (1,2,3))
#for i in range(550):
# cvi.canvas_write_pixel(canvas, 10, i, (0,3,0))
#for i in range(900):
# cvi.canvas_write_pixel(canvas, i, 10, (0,0,3))
#for i in range(900):
#cvi.canvas_write_pixel(canvas, i, i, (3,3,3))
cvi.canvas_write_pixel(canvas, 10, 10, (3,0,0))
cvi.canvas_write_pixel(canvas, 899, 539, (3,0,0))
print("writing to disk")
import time
tic = time.perf_counter()
# cvi.canvas_to_ppm(canvas, "ball2.ppm")
toc = time.perf_counter()
#print("done: " + str(toc-tic) + " seconds")
import matplotlib.pyplot as plt
plt.imshow(canvas.swapaxes(0,1))
plt.show()
Python Class
I have something to admit. I looked up how to do everything you are about to see. Take it with grain of salt, and if you have feedback please check form at bottom of post (click title to break out of infinite scroll 🙂
class Tuple4:
def __init__(self, x:float, y:float, z:float, p:float):
self.x = x
self.y = y
self.z = z
self.p = p
def from_tuple4(t4:tuple4):
return Tuple4(t4[0],t4[1],t4[2],t4[3])
def get_point(x:float, y:float, z:float):
return Tuple4(x,y,z,1)
def get_vector(x:float, y:float, z:float):
return Tuple4(x,y,z,0)
def __repr__(self): #this will give us something nice in jupyter notebook when we eval in place
return "(" + str(self.x) + ", " + str(self.y) + ", " + str(self.z) + ", " + str(self.p) + ")"
def __eq__(self:Tuple4, other):
return tuple_is_equal((self.x, self.y, self.z, self.p), (other.x, other.y, other.z, other.p))
def __add__(self:Tuple4, other):
if (isinstance(other, Tuple4)):
return tuple_add((self.x, self.y, self.z, self.p), (other.x, other.y, other.z, other.p))
New Usage Pattern
Honestly, we need a part ][ of this post to continue 😉
I’m object oriented out. I ❤ Functions. Teaser for next post (objects are entire programs onto themselves, this can be troublesome)
CommandPattern.org 