Software Programming

At this stage, this section on software programming is still in development, but some sections have been initially added primarily in support of the programs used within this website. At the moment, the scope of these programs can, as in the case of JavaScript, be embedded in the HTML of the website to add control features like the drop-down menus, see JavaScript Automation or to provide dynamic user features, such as the Cosmic Calculator. Another language that is used to add dynamic user features is the Java language, see Java Trajectories as an example, although many browsers now seem to block java by default. Another programming language used for offline web development is Visual Basic , see MyWeb: Update Automation for some details of the programs developed for this purpose. Finally, one other language called FreeBasic is being used in connection with a discussion of the Gabriel laFreniere website that uses this language to develop animations; although the context of this website is explained within the Wave Structure of Matter discussion still under development.

Now based on the summary above, it would seem that these programs can be beneficial to the web developer who wants to provide additional features to the web user. However, today, the web user needs to be cautious in using websites that offer such dynamic features, because they can also be used for malicious, as well as beneficial, purposes. While, as the web developer, I may be confident that my own website has no malicious intent, you the web user cannot necessarily be certain, especially for a website that may not be able to provide any independent authentication of its brand name. While you must make your own choice regarding the security risk to your system, it is hoped that by trying to explaining the purpose of the programs on this website, it may also provide some re-assurance while helping me remember what all the various programs are about.

So, by way of an initial introduction to programming in general, it might be recognised that computer programming languages have developed in both sophistication and scope over the last 30-40 years. In the early days, small micro-processing chips had to be programmed using machine code, i.e. a form of hexadecimal code, which was only one step above typing in binary. The next development took the form of assembler languages that often had its own form of hieroglyphics for each chip manufacturer, e.g.

                        mov bx, ax
                        sub bx, 100
                        jge continue
                        mov ax, 100
          continue:
                        mul ax

An exact explanation of the code above is not necessarily for this introduction, but it is possible to guess at a process in which the contents of hardware registers, i.e. ax, bx, are moved, subtracted and compared to perform some arithmetic task. Next on the development timeline came the high-level languages, such as Fortran and Cobol, which also added much sophistication to the development toolbox in the form of compilers and debugging. However, while these high-level languages offered some benefits in terms of code readability, there were initial issues with the processing speed of programs associated with larger and more verbose languages. While, to some extent, the continued increase in hardware processing speed, see Moore's Law, would come to minimise most concerns in this area, another hybrid language called 'C' was developed, which offered some of the the benefits of readability, with additional development tools, without too much degradation of run-time performance in comparison to earlier assembler languages. However, today, the list of computer programming languages has now grown to become a very large list, although the principles governing most of them has remain remarkably similar in scope.

However, there have been one or two fairly fundamental innovations in the timeframe being discussed. For instance, originally, programs were designed and written in a data-centric fashion meaning that data variables were defined and stored independently of the instructions that acted on this data. As a very simple illustrative example, a program to draw a circle might have a variable called radius and a constant called pi . Separately, a function, i.e. the code, would be developed to use radius and pi and output the appropriate sized circle to a screen. However, even a small modification to colour the circle may have required the programmer doing the update to understand of the original design of the data structures and programming before the modification could be worked out. Therefore, in response to this problem, support grew for an alternative methodology called object-orientated programming (OOP) .

While there is no specific discussion of this approach within this website, as yet, we might provide some outline of the idea by adapting the previous illustrative example. Here the original design would have produced an object called circle that contained the variable: radius , the constant: pi and the code: draw_circle . If so, a subsequent modification would only need to define a new object called colour circle that inherited the attributes of the original object circle. However, in practice, there are many pros & cons to this methodology that go beyond the scope of this introduction, which will have to be left to another day. However, there is one other innovation that might be cited as a significant programming development called the Specification and Description Language (SDL), which is a program design and implementation language used to build real-time event-driven systems capable of encompassing parallel processing. One of the main advantages of this approach is that it can hide most of the actual programming code beneath a graphical flow-chart type interface, where the generated program code might be ported to different machines using different operating systems and programming languages. So, in the same way that high-level languages were able to mask the need to understand machine dependent assembler code, SDL can mask the need to understand all the details of a given high-level language and its dependencies on a given operating system. However, again, it needs to be highlighted that there are many pros & cons to this approach that have not been explained at this stage. Where all this development might one-day lead is partially addressed in a discussion entitled Software Technology, while the remainder of the discussions in this section will focus on actual programming languages used within this website; primarily as quick-start guide for anybody wanting to write their own programs using free open-source development tools that can be downloaded from vetted websites on the internet.