Here i go, starting back at the beginning. Sometimes i revisit the basics simply because things don’t add up higher up and it generally means that a fundamental rule is missing from my knowledge.
This morning i picked up my operating systems textbook from Uni and started reading again. It’s fun returning to the basics when you have been cruising up top for a while. It’s a new chance to test some of the assumptions you’ve made about how things work below. I’m reading about the operating system and how the kernel works. How the operating system is made up of separate layers of hardware, kernel, software and applications. And that sometimes the line between kernel mode and user mode is blurry.
This is important. Why? because sometimes the truth is blurry in the real world. I’m not suggesting there isn’t such a thing as absolute truth. That’s an argument for another day (a fun one at that :P). What I mean is that people make software, and when people make things, they make it with incomplete knowledge. Who knows whether there is some greater abstraction that when applied to electrical currents and plasmatic substances will produce greater throughput and quality of work for less effort. But right now we have the good ol’ process abstraction. Without it we wouldn’t have modern computing! If it was more complex we would probably have too much trouble understanding it especially when it comes to parallelism.
As long as humans make stuff, we’ll make it imperfectly. And I wish i realized that earlier on. There are so many libraries out there that have been locked into a particular implementation simply because too many people now depend on it’s API to get things done. when the author realizes his mistake, It’s usually too late. When taking on new projects and exploring new libraries, one needs to anticipate mistakes. Not that we shouldn’t have faith in peoples ability to test and produce quality code, but if we expect perfection from everything we come across, we will become sorely disappointed. think about the first things you produced as a programmer, were they perfect. hopefully not or I’m going to cry.
That being said, some very smart people made the kernel and windows operating system, and It’s usually not the hammer that gets blamed if the hammerer can’t hit his nails. There is a small set of processes and tasks that a programmer has to have confidence in, without that confidence, It’s hard to predict whether anything will work. Even when we think we are calling the most low level function, we are 99% of the time delegating that task to some kernel or even physical hardware mechanism that we did not write ourselves.
So keep striding. nothings perfect, but decide what you will put your trust in. build up a set of libraries that you trust, that the community has already thrashed and when you’re feeling extra adventurous, be that guy that thrashes an alpha or beta library for the sake of helping the guy out. but by no means put these things into production use unless it has been tested to the max. especially financial applications. It’s just not worth the risk.
P.S. I put the extra r in on purpose.