20151018

importance of kiss

with kiss, there's practical real world valid potential to the concept of "more eyes, shallower bugs. sufficient eyes, all bugs shallow."

with increased complexity, there becomes a serial multitude and plethora of disencentivisations discouraging eyes to look upon the code, to understand the code, to see the bugs.

not a call to popularity. one can increase complexity to beyond potential for ANY number of eyes to have any chance of shallowing bugs, let alone making ALL bugs shallow.



tis the concept that most alured me to the foss side of the force. ;)

many eyes.

when something grows to such complexity that no new eye dare look, ~or even to diminish the number of eyes is still too high a price.

i am very keen on the idea that /everyone/ could and likely would look at the code they are running.

this is absurd and far out of reach for us. either the code gets less, or we vastly accelerate our coding capabilities beyond our current biology, and beyond even some of our wildest sci-fi notions.

looks like the code need be kept simple then. in reach.

to let it slip, is to creep in an insidious flaw in free software, to let in malicious features. taking away the 4 essential freedoms isnt the only malisciousness that can be perpetrated upon mass.

all the horrors that spill forth in the dark of proprietary closed-source freedom-restricting "over-a-barrel"-licensed software, the spywares, the malwares, all those nuissance sequestrations of your ram n cpu n hd space to send you subliminals, open your cameras up to perverts or unlawful governments, or steal your bank details or passwords or whatever else, all of that crap, can be slipped in, once no one but the cabal are looking close enough.









have i scared you into learning some code? i hope so. best way to learn, i hear, is to read a lot of code.

have i endeared you to the importance of kiss?

if not, i hope i can.

kiss isnt just a benefit for being a way to prevent something unpleasant (understatement). keeping code simple, keeps it human maleable. on the fly coding can become meaningful. even blur the lines between what's configuration and what's editing code. as use. such that use is development.

and yes, you might say that would lead to bloat. but would it? you might say, yes, it has. free software might be said to be that, in the examples seen, through GNU particularly.

but look at stali. it's quite gnu (despite profestations of being non-gnu, it's still gnu in so far as *it's not unix. so at least nu. ^_^ point being it's small, closer to the human maleable, to give example that free software is not an inevitable trudge to bloat... indeed look at the comparison, proprietary, and how much it bloats. the ratio is amusing. but then, there's bloat and there's bloat... but lets not get into that... or lets...

emacs. emacs is an example of software that retains its attempt at keeping it human maleable such that there's a blurred distinction between coding and configuring. indeed it's jested, not undeservedly, that emacs is a whole operating system, given the bredth of its capabilities. so that bredth makes it perhaps seem /big/. might say bloated. might claim it's all functional n purpusful bloat. but since use and configuration are closely entwined (and configuration and coding being a somewhat blurred distinction), there is at least a path that retains a fluid connection for users to utilise their eyes, keeping all bugs shallow.

special cases you might say then... or, for sake of exploring the potential...

imagine your whole operating system could be read in ... minutes. with photoreading, at a glance.

how shallow then are your bugs?



you might think, but then it'd be capable of nothing.

you'd be surprised, how concise some coding languages can be, how much some coding concepts can leverage and amplify how curt and concise the code can be, how much some clever fractal savvy can do, and how many other things there may be for us to encounter and/or develop.

so imagine you have all the capabilities you need, and more, from a screenfull of code. how shallow then are your bugs?

and actually seeing the real code of it too... i know this might seem like a silly idea if u thought i just meant seeing a pageful of the aliases to much larger pieces of code elsewhere. no. i mean all the code in its entirety.

heck idk, does it even need to be binary? how long before we speak dna inspired code/language?

i could have stopped this blog post at any number of punch points, like a straight-arm microphone-drop moment, like pressing the emphasis button on it... but instead i've got off on a wild sci-fi tangent n ruined my chance to be up on the podium with some title like president or guru. good. ;p

q

Posted by Digit | Permalink