Tony Armani

10/13/2005 14:51:34


It’s good to see a new Oddmuse user, who is at the same time a perl expert. You can also visit my Oddmuse:TonyArmani page in the Oddmuse wiki.

Actual Thoughts

Some TonyArmani Thoughts

“Superior thinking depends not on speed, IQ, language, training, position, presentation, nor salary, but on completeness. If you have complete information, then it is easy to find the right answers, while with incomplete information, even the best and brightest are often wrong.”

After reading such a text part I had the following thoughts about completeness, programming and a new term I introduce as “ProgrammingPathMap”:

So the question to ask oneself is: How can I increase the completeness of my knowledge? Which are the most effective tools to complete my knowledge or information package about the topic of my interest? Some ideas:

  • Where to get the fastest overview? (Not deep information but quick overview. In programming usually tutorials are used to get a first understanding in a new topic, in a special feature…)
  • Where to get the deep information? Where are the most detailed informations available and have we access to them?
  • Where can we see similar examples to enable us a faster starting? Examples can work sometimes as useful templates for a similar problem.
  • How can we increase understanding in this programming language more theoretically than with examles, using a more or less systematic approach on one example code? My new (?) idea here is to use ProgrammingPathMaps. They should be similar to concept maps, combining subject words and verbs to describe your programs code for each element in your program. So this ProgrammingPathMap can deal about tiny details but also be more general explaining the concept of the program or a part of the program. So depending on your interest how deep you want to go to see some new relationships between your program code elements you would choose another “level” of ProgrammingPathMap to use/write. Are ProgrammingPathMaps already used or is there another “official” term for something similar what I described above and defined as ProgrammingPathMaps?

So if you’re asking yourself what should be the benefits of such ProgrammingPathMaps and why using the term “path” here’s my short answer: If you’re already a programming genius with a deep understanding for lots of principles in any code where others have to think much longer than you, you’re the wrong person. You don’t need ProgrammingPathMaps or the benefits to you would not be much, maybe more contrary you would loose time by spending time on ''reading'' or ''viewing'' such ProgrammingPathMaps. But maybe you could earn money, e.g. by writing a book about ProgrammingPathMaps using your deep understanding level between program source code elements. Now I come to the second part, why I included the term “path” using a ThoughtExperiment, but not such genius ThoughtExperiments as AlbertEinstein did :) Think of it as a ''primitive'' ThoughtExperiment or just an example: If you’re a programmer at around 60% skills of a genius programmer, usually you start programming (if you start at all) by combining other tools, programs, modules, written by others. So after making a search what’s available in the OpenSource market, you take it, and try to modify it according to your needs. It should not take much time to find the right place in the SourceCode to start. Here comes the funny part. What we have done so far is just taking the Source of somebody else and jumped to the place where we want to edit. BUT we didn’t edit anything yet. Your finger is directly over the first key you will touch in some milli seconds. Now we STOP. Where are we now? Yes, you’re sitting on your chair, but where are we in the source code? Here comes the answer: We are on some place in the path of elements of the source code. If we consider the whole source code as a combination of logical elements in some way, the cursor will modify in some milliseconds (after our first touch with the first key) one such logical element. Each logical element has a path, meaning there are lots of other logical elements which come before and also after this LogicalElement. The goal of ProgrammingPathMaps should be to show such relationships between LogicalElements as described before to increase understanding for this programming language.

I hope my text was easy to follow and understand. You’re welcome to share your thoughts here, it would be great. In my opinion less skilled programmers could use such ProgrammingPathMaps to learn more and more in a fast way which part of the code is influencing which other related parts and knowing in which parts exactly you have to modify the code that the result will work appropriately. At least this is my main problem when I want to modify a new code.

Btw. I’ve created a new wiki here for continuing with these thoughts.


  • If you’re interested in a small discussion about PageClusters and NameSpaces just continue here: [[Comments on TonyArmani]] (But it’s nothing special and new.)

Similar Pages