While working with a student in a freshman computing course, this advice was given:
A first programming course can be quite a challenge, or it can be very easy. Much of your success in a first time course depends upon your previous coursework and preparation.
If you are not as successful as you would like in this course, do not quit. Keep trying and work on filling in "gaps in your learning and preparation".
You can do this. Anyone can.
This is true of any academic subject. Academic fields are based upon "rules", applying them, and deducing them.
If you can understand and follow the legal code in your city, province, or country, you have all of the reasoning power needed for understanding or studying any subject, Learn the rules well and how one applies them. Make flashcards, if you must. That is all that it takes.
Similar advice was shared with a classmate who was rather amazed at the author's work as a NIH scientific apprentice while in high school. She used this simple advice, including the flashcards, and earnt a doctorate in organic chemistry.
She now has a significant role in an international pharmaceutical company. She even proudly displayed her set of homemade flashcards with benzene, aromatic rings, and aliphatic chains, when she met with the author briefly one evening when he studied at Grinnell College. Great Job, KC!
Genuis is 95% practice, 4.9999999999% chance, and 0.0000000001% natural gifting.
Monday, July 8, 2019
Communicating With a Computer - The Programmer's Perspective
The author has the pleasure of teaching an online course in Python at this time for the University of the People. This is a low-cost international distance education opportunity for many across the globe.
Note: UoPeople could use some more computing instructors, if you have a masters or doctorate degree in a computing discipline. Simply apply at www.uopeople.edu.
While working with these students, many who had not taken a previous computer programming course, he sought a way of expressing the simplicity of computing.
And, when simply put, one is communicating with a computer when programming. One simply gives the computer a list of commands, that could be easily spoken in this day of speech recognition. Then, the computer performs these tasks the same way that one would if he were checking the commands for accuracy.
The following passage was shared with the author's students:
Python Programming Explained In Terms Of English.
This is five typed pages and 1083 words, nearly a short paper. You already have plenty of reading for the week, but some of the comments in this passage might address some of your confusion, if you have been struggling with Python. You can read it, if you have time. It is not required.
For some of the class, this will be overly simplified. For others, it will be “spot on”. Summarizing all of the basic abstractions concerning computer programming in a few paragraphs is a near impossibility. But, I will try. Hopefully, this will shine a light on the darkness in which some of you find yourselves.
Electronic computers can complete some amazing feats of computation, but they can only do what they are told. They cannot reason outside those bounds. When we communicate with computers, we do so with an intermediary language. It is not their mother tongue, which is a series of “low-level” commands most naturally expressed with zeros and ones. And, it is not a “natural spoken” language such as Hindi. It is somewhere in between. It is called a “high-level” language, because it is human-readable and not written in a cryptic string of zeros and ones.
“High-level” computer programming languages come in differing classes. The most common class of such languages are those based upon giving the computer “commands” that it must perform. These are called “imperative” languages. In the English language, an “imperative” sentence would be, “Open the door”, a direct “command”. In this sentence, the subject, “You”, proceeding “open” is implied.
So, the following Python command:
>>>print(“Hello World”)
Could be “mentally” read as:
Computer, print the phrase “Hello World” on your screen.
The following commands for calculating the area of a circle:
>>>radius = 5
>>>approximatePI = 3.14
>>>circleArea = approximatePI * radius**2
Could be “read” as:
Computer give the storage location called “radius” a value of five.
Computer store the value of 3.14 in the data location called “approximatePI”.
Computer compute the value produced by what is in the storage location called “approximatePI” multiplied by the square of the value in the data location called “radius” and place the result in a position within memory named “circleArea”.
It must be noted that if you tell the computer that it should do the wrong thing; it will do it “faithfully” every time.
These commands, also called imperatives, that we give a computer follow a format and have certain rules of structure as do spoken languages. Natural languages often have subjects, explicit or implicit, and predicates with verbs plus indirect and direct objects. Also, they contain certain modifiers for the nouns and verbs used in them. And, they use punctuation for signaling certain parts of the sentence, such as the end, with a period or question mark. In Python, the end of each command is simply the end of the line on which it sits. This is marked by a couple of non-printing characters, the carriage return and the line feed. Also, punctuation such as ( ) { } [ ] , “ ' # and others have significance and express something important about the current Python statement. Plus, the punctuation must be used in a certain way so it is meaningful and correctly expresses what the programmer intended.
One of Python's unique features that is not found among many other programming languages is the importance of the program's “indenting” pattern. In most other languages, indenting is simply added for readability. But, it Python, it effects how the interpreter “parses” and understands that commands that is given. A “missing” or “misplaced” indentation can result in a syntax or run-time error, plus it can produce erroneous output although a program completes successfully.
Also, from some of the discussion comments during the second units, it seems that some of the class struggles with the difference between a simple series of instructions in a script and a “well-defined” function.
For instance, if one had the instructions above that calculate the area of a circle, your assignment required that you calculated three areas for the radii of length 5, 10, and 20, plus you did not use a “well-defined” function, then you must list those three instructions three times. Such a program would appear as below:
>>>radius = 5
>>>approximatePI = 3.14
>>>circleArea = approximatePI * radius**2
>>>print( “The area for a radius of “ + str(radius) + “ is “ + str(circleArea) )
>>>radius = 10
>>>approximatePI = 3.14
>>>circleArea = approximatePI * radius**2
>>>print( “The area for a radius of “ + str(radius) + “ is “ + str(circleArea) )
>>>radius = 20
>>>approximatePI = 3.14
>>>circleArea = approximatePI * radius**2
>>>print( “The area for a radius of “ + str(radius) + “ is “ + str(circleArea) )
This is somewhat overly redundant since the value of “approximatePI” does not change and could be set once at the beginning of the list of instructions and then used throughout. Yet, the point is that this usage of Python in not “well-structured” or practical. If for some reason, you needed the surface area of a sphere with that given radius, the calculation of the area and its associated variable name must change in a number of places.
This is why we use the keyword “def” which stands for “define” in Python and create modular functions with it. The modules give our programs structure. Plus, they support the “structured programming” policy of having a “single-point” of modification when corrections or enhancements must be made. A program with a function for determining these areas of a square would be as follows:
import math
def measureCircleArea( radius ):
areaString = str( math.pi * radius**2 )
return areaString
print( "The area of a circle with a radius of 5 is " + measureCircleArea( 5 ))
print( "The area of a circle with a radius of 10 is " + measureCircleArea( 10 ))
print( "The area of a circle with a radius of 20 is " + measureCircleArea( 20 ))
This program could be “mentally” read as follows:
Computer, search the files in the Python libraries on this computer for a module called “math” and “import” all of its functions and predefined values for use in this program.
Computer, next define a function with the name “measureCircleArea” that accepts one input, a formal parameter called “radius”.
Computer, when the “measureCircleArea” function is called with an actual argument that should be a number, complete all of the steps that are indented by at least one tab character until you reach a return statement or the indenting stops that started after the function header prefixed with “def”.
Computer, the first step that you should complete for “measureCircleArea” is multiplying a value for the number PI, “math.pi”, that came from the imported library module, by the square of the formal parameter “radius” and store this in a temporary data location called “areaString”, after taking the numeric result and making a string from it with the str() type conversion function.
Computer, next “return” the value in “areaString” for use by the calling program.
Computer, this represents the end of the module “measureCircleArea” as the return has been reached and the program source outdents again.
Computer, for the first line of the programming script that you will execute when this program is called, print on a single line the following phrase, “The area of a circle with a radius of 5 is “ suffixed with the result of performing the “measureCircleArea” function with an input of 5.
Computer, for the next line of the programming script that you will execute when this program is called, print on a single line the following phrase, “The area of a circle with a radius of 10 is “ suffixed with the result of performing the “measureCircleArea” function with an input of 10.
Computer, for the final line of this programming script that you will execute when it is called, print on a single line the following phrase, “The area of a circle with a radius of 20 is “ suffixed with the result of performing the “measureCircleArea” function with an input of 20.
We could have used a variable like “approximatePI” whose value we defined as 3.14, but we used the value of pi stored in a special Python library for mathematical operations. This was done so one concept could be reinforced. The importance of “structure” and modules, such as functions, or subroutines. Someone has written a series of mathematical routines for use by any Python programmer and placed them in a module called “math”. These sub-modules, such as sin() for sine, cos() for cosine, atan() for arctangent, and etc. are available for use by anyone who imports math. Plus, the module contains a number of predefined values that cannot change such as pi.
The important lesson here is that when you learn enough about Python you can write your own modules such as “math” and compile libraries of them. This means that you only must write a function once. Then, you can reuse it many times.
Also, it seems that some of you still have a struggle with the concept of a variable. These are like the variables in algebra, in that, they can take on a wide array of values. But, they are a “little” different in that they represent a label for a location in the computer's memory. If you must use data in your program, you must store it somewhere. Plus, you must have a way of referencing this information. Python is really flexible with variables, in that they can accept data of any type. This is called “dynamic” typing. In many other languages, one must specify the type of data which a certain variable can accept. This specification occurs when you name the variable. This is called “static” typing. Python is much different. One can simply create a meaningful name for a variable. This name is called an identifier. After creating a variable's identifier, one can just store a value in it without specifying any limits on the type of data that it can hold. For instance, the following variable receives a string variable, is printed, is assigned an integer, and then is printed again.
>>>courseNumber = “CS1101”
>>>print( courseNumber ) #prints CS1101
>>>courseNumber = 1101
>>>print( courseNumber ) #prints 1101
In most cases, Python variables must have something stored in them before they are used or an error will occur. Something is stored in them when one uses the assignment operator, =.
Hopefully, that was helpful and not a burden. You already have plenty of reading for the week. If you have any specific questions about any particular Python topic, please send them. Also, please take the time and focus your questions. General questions often get general answers which might not meet your needs.
Note: When this passage was shared in an early term, one student who had some programming experience mentioned that this was a very simplistic view of what was occurring. Plus, he said that much was left out, such as the interaction of the program with the computer's memory. But, these details are not absolutely essential for understanding enough that one can write programs with variables, functions, and other programming structures.
Note: UoPeople could use some more computing instructors, if you have a masters or doctorate degree in a computing discipline. Simply apply at www.uopeople.edu.
While working with these students, many who had not taken a previous computer programming course, he sought a way of expressing the simplicity of computing.
And, when simply put, one is communicating with a computer when programming. One simply gives the computer a list of commands, that could be easily spoken in this day of speech recognition. Then, the computer performs these tasks the same way that one would if he were checking the commands for accuracy.
The following passage was shared with the author's students:
Python Programming Explained In Terms Of English.
This is five typed pages and 1083 words, nearly a short paper. You already have plenty of reading for the week, but some of the comments in this passage might address some of your confusion, if you have been struggling with Python. You can read it, if you have time. It is not required.
For some of the class, this will be overly simplified. For others, it will be “spot on”. Summarizing all of the basic abstractions concerning computer programming in a few paragraphs is a near impossibility. But, I will try. Hopefully, this will shine a light on the darkness in which some of you find yourselves.
Electronic computers can complete some amazing feats of computation, but they can only do what they are told. They cannot reason outside those bounds. When we communicate with computers, we do so with an intermediary language. It is not their mother tongue, which is a series of “low-level” commands most naturally expressed with zeros and ones. And, it is not a “natural spoken” language such as Hindi. It is somewhere in between. It is called a “high-level” language, because it is human-readable and not written in a cryptic string of zeros and ones.
“High-level” computer programming languages come in differing classes. The most common class of such languages are those based upon giving the computer “commands” that it must perform. These are called “imperative” languages. In the English language, an “imperative” sentence would be, “Open the door”, a direct “command”. In this sentence, the subject, “You”, proceeding “open” is implied.
So, the following Python command:
>>>print(“Hello World”)
Could be “mentally” read as:
Computer, print the phrase “Hello World” on your screen.
The following commands for calculating the area of a circle:
>>>radius = 5
>>>approximatePI = 3.14
>>>circleArea = approximatePI * radius**2
Could be “read” as:
Computer give the storage location called “radius” a value of five.
Computer store the value of 3.14 in the data location called “approximatePI”.
Computer compute the value produced by what is in the storage location called “approximatePI” multiplied by the square of the value in the data location called “radius” and place the result in a position within memory named “circleArea”.
It must be noted that if you tell the computer that it should do the wrong thing; it will do it “faithfully” every time.
These commands, also called imperatives, that we give a computer follow a format and have certain rules of structure as do spoken languages. Natural languages often have subjects, explicit or implicit, and predicates with verbs plus indirect and direct objects. Also, they contain certain modifiers for the nouns and verbs used in them. And, they use punctuation for signaling certain parts of the sentence, such as the end, with a period or question mark. In Python, the end of each command is simply the end of the line on which it sits. This is marked by a couple of non-printing characters, the carriage return and the line feed. Also, punctuation such as ( ) { } [ ] , “ ' # and others have significance and express something important about the current Python statement. Plus, the punctuation must be used in a certain way so it is meaningful and correctly expresses what the programmer intended.
One of Python's unique features that is not found among many other programming languages is the importance of the program's “indenting” pattern. In most other languages, indenting is simply added for readability. But, it Python, it effects how the interpreter “parses” and understands that commands that is given. A “missing” or “misplaced” indentation can result in a syntax or run-time error, plus it can produce erroneous output although a program completes successfully.
Also, from some of the discussion comments during the second units, it seems that some of the class struggles with the difference between a simple series of instructions in a script and a “well-defined” function.
For instance, if one had the instructions above that calculate the area of a circle, your assignment required that you calculated three areas for the radii of length 5, 10, and 20, plus you did not use a “well-defined” function, then you must list those three instructions three times. Such a program would appear as below:
>>>radius = 5
>>>approximatePI = 3.14
>>>circleArea = approximatePI * radius**2
>>>print( “The area for a radius of “ + str(radius) + “ is “ + str(circleArea) )
>>>radius = 10
>>>approximatePI = 3.14
>>>circleArea = approximatePI * radius**2
>>>print( “The area for a radius of “ + str(radius) + “ is “ + str(circleArea) )
>>>radius = 20
>>>approximatePI = 3.14
>>>circleArea = approximatePI * radius**2
>>>print( “The area for a radius of “ + str(radius) + “ is “ + str(circleArea) )
This is somewhat overly redundant since the value of “approximatePI” does not change and could be set once at the beginning of the list of instructions and then used throughout. Yet, the point is that this usage of Python in not “well-structured” or practical. If for some reason, you needed the surface area of a sphere with that given radius, the calculation of the area and its associated variable name must change in a number of places.
This is why we use the keyword “def” which stands for “define” in Python and create modular functions with it. The modules give our programs structure. Plus, they support the “structured programming” policy of having a “single-point” of modification when corrections or enhancements must be made. A program with a function for determining these areas of a square would be as follows:
import math
def measureCircleArea( radius ):
areaString = str( math.pi * radius**2 )
return areaString
print( "The area of a circle with a radius of 5 is " + measureCircleArea( 5 ))
print( "The area of a circle with a radius of 10 is " + measureCircleArea( 10 ))
print( "The area of a circle with a radius of 20 is " + measureCircleArea( 20 ))
This program could be “mentally” read as follows:
Computer, search the files in the Python libraries on this computer for a module called “math” and “import” all of its functions and predefined values for use in this program.
Computer, next define a function with the name “measureCircleArea” that accepts one input, a formal parameter called “radius”.
Computer, when the “measureCircleArea” function is called with an actual argument that should be a number, complete all of the steps that are indented by at least one tab character until you reach a return statement or the indenting stops that started after the function header prefixed with “def”.
Computer, the first step that you should complete for “measureCircleArea” is multiplying a value for the number PI, “math.pi”, that came from the imported library module, by the square of the formal parameter “radius” and store this in a temporary data location called “areaString”, after taking the numeric result and making a string from it with the str() type conversion function.
Computer, next “return” the value in “areaString” for use by the calling program.
Computer, this represents the end of the module “measureCircleArea” as the return has been reached and the program source outdents again.
Computer, for the first line of the programming script that you will execute when this program is called, print on a single line the following phrase, “The area of a circle with a radius of 5 is “ suffixed with the result of performing the “measureCircleArea” function with an input of 5.
Computer, for the next line of the programming script that you will execute when this program is called, print on a single line the following phrase, “The area of a circle with a radius of 10 is “ suffixed with the result of performing the “measureCircleArea” function with an input of 10.
Computer, for the final line of this programming script that you will execute when it is called, print on a single line the following phrase, “The area of a circle with a radius of 20 is “ suffixed with the result of performing the “measureCircleArea” function with an input of 20.
We could have used a variable like “approximatePI” whose value we defined as 3.14, but we used the value of pi stored in a special Python library for mathematical operations. This was done so one concept could be reinforced. The importance of “structure” and modules, such as functions, or subroutines. Someone has written a series of mathematical routines for use by any Python programmer and placed them in a module called “math”. These sub-modules, such as sin() for sine, cos() for cosine, atan() for arctangent, and etc. are available for use by anyone who imports math. Plus, the module contains a number of predefined values that cannot change such as pi.
The important lesson here is that when you learn enough about Python you can write your own modules such as “math” and compile libraries of them. This means that you only must write a function once. Then, you can reuse it many times.
Also, it seems that some of you still have a struggle with the concept of a variable. These are like the variables in algebra, in that, they can take on a wide array of values. But, they are a “little” different in that they represent a label for a location in the computer's memory. If you must use data in your program, you must store it somewhere. Plus, you must have a way of referencing this information. Python is really flexible with variables, in that they can accept data of any type. This is called “dynamic” typing. In many other languages, one must specify the type of data which a certain variable can accept. This specification occurs when you name the variable. This is called “static” typing. Python is much different. One can simply create a meaningful name for a variable. This name is called an identifier. After creating a variable's identifier, one can just store a value in it without specifying any limits on the type of data that it can hold. For instance, the following variable receives a string variable, is printed, is assigned an integer, and then is printed again.
>>>courseNumber = “CS1101”
>>>print( courseNumber ) #prints CS1101
>>>courseNumber = 1101
>>>print( courseNumber ) #prints 1101
In most cases, Python variables must have something stored in them before they are used or an error will occur. Something is stored in them when one uses the assignment operator, =.
Hopefully, that was helpful and not a burden. You already have plenty of reading for the week. If you have any specific questions about any particular Python topic, please send them. Also, please take the time and focus your questions. General questions often get general answers which might not meet your needs.
Note: When this passage was shared in an early term, one student who had some programming experience mentioned that this was a very simplistic view of what was occurring. Plus, he said that much was left out, such as the interaction of the program with the computer's memory. But, these details are not absolutely essential for understanding enough that one can write programs with variables, functions, and other programming structures.
But, most of all, remember that one should hunt, peck. and think while programming.
Wednesday, March 13, 2019
Everything that Rises Must Converge
Team. This phrase, "Everything That Rises Must Converge" is all that the author remembers from a text read while in English 104W at Vanderbilt University during the Spring of 1989 taught by adjunct professor Robert Bacon. It was the work's title. A work written by Flannery O'Connor, a celebrated writer from the American South. In this title is a plethora of philosophies.
In the Arts, the concept of perspective is commonplace. A landscape's rendering without this would be seemingly strange in appearance. And, with all things tangible, one's life has a perspective and its own unique beauty. A pleasantness in form that is much like the simultaneously transient and timeless loveliness that an artist tries capturing when recording a moment in time on canvas. This is perspective in the Arts. In the Sciences, based on ratio and measure, the bi-stable cornerstone of reason, perspective is often synonymous with one's philosophical standing resting at an advantageous vantage-point, a position that provides a lucid view of the elegant simplicity of a subject or concept while letting one be conversant concerning its grandest complexities. Yet, in Art and Science, parallels exist in terms of the notion of "perspective".
It has been said that "in higher-order geometries parallel lines meet at infinity".
So, whether one is a Cambridge graduate student in mathematics studying the finest nuances of advanced topology in the damp airiness and silent hum of an historic English library or a kindergartner working with finger-paints shortly before Ms. Tschetter places a graham cracker and a carton of milk in the right-hand corner of your work area, resident in the recesses of your mind is that aforementioned simple concept. And, this abstraction guides your thoughts and actions, ultimately shaping your work-product. Perspective is subliminal. It is etched in the subconscious.
If one has the proper "perspective", one shall perform his work tasks well. This also is true in computing. One must understand the simplest of abstractions surrounding the work one does, before he can deal with the intricacy of the concrete details well.
The same is true of programming a computer. The task of programming is best fit within the realm of engineering, whether formal or informal. And, engineering processes are used in the resolution of a problems. So, in terms of abstractions. The field of problem-solving is a super-set of engineering. In other words, certain tasks in problems-solving are outside the realm of engineering. For instance, satisfying the growl in your stomach is a problem that must be solved. Yet, its solution does not and should not require the disciplined use of engineering concepts. And, engineering as a field is a super-set of computing and programming. Certain engineering tasks will not require the use of computer programming in their resolution. This includes tasks such as erecting steel outbuildings for agriculturalists.
Also, before one can consider himself an accomplished, or "professional" computer programmer, he should have mastery is certain sub-disciplines of computing. These include data structures, algorithms, automata, and the theory of computation. And, from the standpoint of abstractions, that last list is backward. Yet, based upon the level of mathematical sophistication required for mastering the theory of computation and its abstraction, it unfortunately is usually taught after basic courses in programming and its concrete concepts. It really should proceed these for the "best learning outcomes". So, the path of mastery in computer programming is palindromic: programming, data structures, algorithms, automata, and the theory of computation followed by the reversed path theory through programming.
That is a lot of learning. And, one must not known everything about each subject. He just must master the ten or so fundamental learning objectives in each course. And, as he mulls over these concepts and builds interconnections between them, he shall converge upon new innovative insights that will rise up in his inner thoughts. Ultimately, everything which converges must rise.
And, with only a basic understanding of Pascal, elementary data structures, simplistic algorithmic analysis and approximation algorithms, and the briefest description of a Turing machine, this phenomenon of intellectual convergence occurred one sunny weekend afternoon in a freshman quadrangle at Vanderbilt University in the Spring of 1989. These thoughts eventually rose producing JAVA, objects, and much more that is universal, ubiquitous, and useful in modern everyday computing.
In the Arts, the concept of perspective is commonplace. A landscape's rendering without this would be seemingly strange in appearance. And, with all things tangible, one's life has a perspective and its own unique beauty. A pleasantness in form that is much like the simultaneously transient and timeless loveliness that an artist tries capturing when recording a moment in time on canvas. This is perspective in the Arts. In the Sciences, based on ratio and measure, the bi-stable cornerstone of reason, perspective is often synonymous with one's philosophical standing resting at an advantageous vantage-point, a position that provides a lucid view of the elegant simplicity of a subject or concept while letting one be conversant concerning its grandest complexities. Yet, in Art and Science, parallels exist in terms of the notion of "perspective".
It has been said that "in higher-order geometries parallel lines meet at infinity".
So, whether one is a Cambridge graduate student in mathematics studying the finest nuances of advanced topology in the damp airiness and silent hum of an historic English library or a kindergartner working with finger-paints shortly before Ms. Tschetter places a graham cracker and a carton of milk in the right-hand corner of your work area, resident in the recesses of your mind is that aforementioned simple concept. And, this abstraction guides your thoughts and actions, ultimately shaping your work-product. Perspective is subliminal. It is etched in the subconscious.
If one has the proper "perspective", one shall perform his work tasks well. This also is true in computing. One must understand the simplest of abstractions surrounding the work one does, before he can deal with the intricacy of the concrete details well.
The same is true of programming a computer. The task of programming is best fit within the realm of engineering, whether formal or informal. And, engineering processes are used in the resolution of a problems. So, in terms of abstractions. The field of problem-solving is a super-set of engineering. In other words, certain tasks in problems-solving are outside the realm of engineering. For instance, satisfying the growl in your stomach is a problem that must be solved. Yet, its solution does not and should not require the disciplined use of engineering concepts. And, engineering as a field is a super-set of computing and programming. Certain engineering tasks will not require the use of computer programming in their resolution. This includes tasks such as erecting steel outbuildings for agriculturalists.
Also, before one can consider himself an accomplished, or "professional" computer programmer, he should have mastery is certain sub-disciplines of computing. These include data structures, algorithms, automata, and the theory of computation. And, from the standpoint of abstractions, that last list is backward. Yet, based upon the level of mathematical sophistication required for mastering the theory of computation and its abstraction, it unfortunately is usually taught after basic courses in programming and its concrete concepts. It really should proceed these for the "best learning outcomes". So, the path of mastery in computer programming is palindromic: programming, data structures, algorithms, automata, and the theory of computation followed by the reversed path theory through programming.
That is a lot of learning. And, one must not known everything about each subject. He just must master the ten or so fundamental learning objectives in each course. And, as he mulls over these concepts and builds interconnections between them, he shall converge upon new innovative insights that will rise up in his inner thoughts. Ultimately, everything which converges must rise.
And, with only a basic understanding of Pascal, elementary data structures, simplistic algorithmic analysis and approximation algorithms, and the briefest description of a Turing machine, this phenomenon of intellectual convergence occurred one sunny weekend afternoon in a freshman quadrangle at Vanderbilt University in the Spring of 1989. These thoughts eventually rose producing JAVA, objects, and much more that is universal, ubiquitous, and useful in modern everyday computing.
Sub-Titled : In The Quadrangle
Team. It seems that we have at least a pair of outstanding tasks which this weblog has promised. The first item is a book on programming fundamentals. The second is an open virtual machine, with a base of primitive instructions, that one can port between differing language application programming interfaces. The next "few" entries in this web-history should address each of these goals.
We will be working on a book that discusses programming starting with the abstractions found in general problem solving, seguing through the concepts in basic engineering, such as processes for building and recycling resources, and ending upon the foundational concepts in computer programming: algorithms, data structures, and automatons. In the process, the text's capstone project will be the "open" virtual machine.
The text will be sub-titled, "In The Quadrangle".
A previous "web-post" outlines some of the author's experiences while briefly studying at Vanderbilt University during the Spring semester of 1989. In summary, while taking an introductory computing elective in Pascal, he spent one sunny weekend afternoon daydreaming and brainstorming in his dorm-room which lay near West End Avenue and Twenty-First Street during those years. These thoughts intermingled with memories of his freshman sweetheart and bus-riding companion, resulted in some of the most influential concepts in modern computing after they were shared with his instructor and classmates at Vanderbilt plus, most importantly, family members who worked in executive leadership at Sun Microsystems, during the 1980s through the millennium.
Concepts which have taken hold in the modern era were quite easily conceived by an insightful computing novice and amateur, yet they required the skills of professional engineers and computer scientist before they became part of everyday life. These concepts include object-orientation, architectures, programming-by-contract (rebranded "design-by-contract"), prefabricate structures (frameworks, patterns, templates, and stencils), generics, and the basic feature set of JAVA as a language with a "C-like" syntax.
Tons of low-hanging fruit and fallen fruit existed in the computing world of the late-1980s. Much still exists this day in the area of concern partitioning, the use of general-purpose structures, and other subareas of computing and software engineering.
The goal of the introductory section of this text will be putting it all in perspective: problem-solving, engineering, and computer programming.
The author will develop some exerts of this "planned" text on-line in this web-history.
We will be working on a book that discusses programming starting with the abstractions found in general problem solving, seguing through the concepts in basic engineering, such as processes for building and recycling resources, and ending upon the foundational concepts in computer programming: algorithms, data structures, and automatons. In the process, the text's capstone project will be the "open" virtual machine.
The text will be sub-titled, "In The Quadrangle".
A previous "web-post" outlines some of the author's experiences while briefly studying at Vanderbilt University during the Spring semester of 1989. In summary, while taking an introductory computing elective in Pascal, he spent one sunny weekend afternoon daydreaming and brainstorming in his dorm-room which lay near West End Avenue and Twenty-First Street during those years. These thoughts intermingled with memories of his freshman sweetheart and bus-riding companion, resulted in some of the most influential concepts in modern computing after they were shared with his instructor and classmates at Vanderbilt plus, most importantly, family members who worked in executive leadership at Sun Microsystems, during the 1980s through the millennium.
Concepts which have taken hold in the modern era were quite easily conceived by an insightful computing novice and amateur, yet they required the skills of professional engineers and computer scientist before they became part of everyday life. These concepts include object-orientation, architectures, programming-by-contract (rebranded "design-by-contract"), prefabricate structures (frameworks, patterns, templates, and stencils), generics, and the basic feature set of JAVA as a language with a "C-like" syntax.
Tons of low-hanging fruit and fallen fruit existed in the computing world of the late-1980s. Much still exists this day in the area of concern partitioning, the use of general-purpose structures, and other subareas of computing and software engineering.
The goal of the introductory section of this text will be putting it all in perspective: problem-solving, engineering, and computer programming.
The author will develop some exerts of this "planned" text on-line in this web-history.
Tuesday, February 12, 2019
Duke-Orientation by Boonie the Ace
Team. It is said that as we age we forget some of the basic fundamentals learnt as children. This is one reason that researchers in advanced fields often redraft complex research problems in simple elementary terms and then see if a K-12 student can solve one or more of them.
Well, how is your natural Duke-Orientation, in light of your advanced degrees in computing, information, and the sciences or numerous years of experiences with the most advanced concepts in this field. Can you find the upper-left corner of the screen and now the lower-right?
Let us ask Duke?
Did you do an about face in your desk chair, once you where properly oriented?
The following portable document file should help you relearn what you have forgotten. Share it with a friend in computing. Maybe this will help us all sort out the RHS := LHS inversion in formal languages. It will not change the nature of the production, but one might find that he can think more freely and follow blindly less often.
Subconsciously, when one's left side is on the left of the entity with which he is facing and communicating, he is necessarily behind the entity and following. When one is oriented left-on-right and right-on-left, he can communicate and think freely, breaking away from the discussion for a moment of reasoning and returning later so he might add a few salient points.
A similar note was placed earlier in this weblog, yet this fact on "modern lateral disorientation" was repeated. It seems that this legacy is slowly seeing adoption among the future generations as "natural" and is deemed healthy and acceptable. Yet, it is simply one of many "new normals" which is one of yesteryear's "gross dysfunctions".
Sayings such as "righty-tighty" and "lefty-loosey" were for those who had trouble telling time on an analog clock. "Clockwise" tightens a threaded bolt and "Counter-clockwise" loosens. And, considering the rise in digital time-pieces, the "new normal" for orienting one with what he is facing, and that classic freshman Pascal-dilemma ( lhs := rhs ), our modern zeitgeist does not speak well of the current international pool of free thinkers. This pool includes the author who was inverted for about a decade after taking a course in data structures that discussed left and right sub-trees that, at first, seemed out of place and then, gradually over time, appeared properly-oriented.
Hunt. Peck. Think. It works quite well for the birds...
Well, how is your natural Duke-Orientation, in light of your advanced degrees in computing, information, and the sciences or numerous years of experiences with the most advanced concepts in this field. Can you find the upper-left corner of the screen and now the lower-right?
Let us ask Duke?
Did you do an about face in your desk chair, once you where properly oriented?
The following portable document file should help you relearn what you have forgotten. Share it with a friend in computing. Maybe this will help us all sort out the RHS := LHS inversion in formal languages. It will not change the nature of the production, but one might find that he can think more freely and follow blindly less often.
Subconsciously, when one's left side is on the left of the entity with which he is facing and communicating, he is necessarily behind the entity and following. When one is oriented left-on-right and right-on-left, he can communicate and think freely, breaking away from the discussion for a moment of reasoning and returning later so he might add a few salient points.
A similar note was placed earlier in this weblog, yet this fact on "modern lateral disorientation" was repeated. It seems that this legacy is slowly seeing adoption among the future generations as "natural" and is deemed healthy and acceptable. Yet, it is simply one of many "new normals" which is one of yesteryear's "gross dysfunctions".
Sayings such as "righty-tighty" and "lefty-loosey" were for those who had trouble telling time on an analog clock. "Clockwise" tightens a threaded bolt and "Counter-clockwise" loosens. And, considering the rise in digital time-pieces, the "new normal" for orienting one with what he is facing, and that classic freshman Pascal-dilemma ( lhs := rhs ), our modern zeitgeist does not speak well of the current international pool of free thinkers. This pool includes the author who was inverted for about a decade after taking a course in data structures that discussed left and right sub-trees that, at first, seemed out of place and then, gradually over time, appeared properly-oriented.
Hunt. Peck. Think. It works quite well for the birds...
Sunday, September 30, 2018
First Step for a Business Machine with an International Reach | OPEN-VM
Team. The author is working on another short text that discusses how one might produce any computer program starting from "Hello, World!" and evolving. A small-snippet from the background chapter can be found here.
Hunt. Peck. Think.. and enjoy this season of life...
Hunt. Peck. Think.. and enjoy this season of life...
Friday, August 31, 2018
OPEN-VM | A CABOOSE Port
Team. A controller, for the most part, processes inbound request for views of an internal data model. The "inbound request" can be seen as issued commands. As such, a controller and command-processor are very similar in construction. And, at the lowest level a computer simply processes a stream of imperatives, a.k.a commands. So, a virtual machine, the software equivalent of a hard-wired system unit simply is a mechanism for interpreting and handling such sequences of computing instructions.
The original vision behind an OPEN-VM was that it would "open-up" a platform's high-level language's application programming interface for use by a set of common cross-platform imperatives, that are universal for all of the platforms on which the OPEN-VM is written.
The commands that one might find in the OPEN-VM language set come in three categories: basic (primitive), flow of control, and grouping.
The basic ( foundational and universal ) commands would be: assign, behave, construct, and destruct.
The flow of control commands would be: if-then-else, switch-case-default, while-do, repeat-until, and for.
The above includes branching, pretest and post-test sentinel controlled loops, plus counter-controlled iteration ( a.k.a looping ).
Finally, the grouping commands would allow for combining program parts forming concern structures, such as methods, data-blocks, objects, and etc.
These three classes of command would allow for the "structured-use" of the concerns found in a platform's programming interface.
This would be one style of universality available, that could evolve as language platforms and methods of concern partitioning matured.
It, the OPEN-VM, was implementable within the scope of structured C, COBOL, FORTRAN, and old Pascal. Yet, it would have likely not been as effective or impactful as JAVA will be, is, and has been.
Enjoy your Labor Day...Hunt...Peck...and...Think...It makes for a brighter day!
The original vision behind an OPEN-VM was that it would "open-up" a platform's high-level language's application programming interface for use by a set of common cross-platform imperatives, that are universal for all of the platforms on which the OPEN-VM is written.
The commands that one might find in the OPEN-VM language set come in three categories: basic (primitive), flow of control, and grouping.
The basic ( foundational and universal ) commands would be: assign, behave, construct, and destruct.
The flow of control commands would be: if-then-else, switch-case-default, while-do, repeat-until, and for.
The above includes branching, pretest and post-test sentinel controlled loops, plus counter-controlled iteration ( a.k.a looping ).
Finally, the grouping commands would allow for combining program parts forming concern structures, such as methods, data-blocks, objects, and etc.
These three classes of command would allow for the "structured-use" of the concerns found in a platform's programming interface.
This would be one style of universality available, that could evolve as language platforms and methods of concern partitioning matured.
It, the OPEN-VM, was implementable within the scope of structured C, COBOL, FORTRAN, and old Pascal. Yet, it would have likely not been as effective or impactful as JAVA will be, is, and has been.
Enjoy your Labor Day...Hunt...Peck...and...Think...It makes for a brighter day!
Subscribe to:
Posts (Atom)