Einstein explained the experimental characteristics of the photo-electric effect by the concept that the photon is a localized packet of electromagnetic radiation with the mechanism: photon + atom → emitted electron. A classical plane wave theory of light concluding that the photoelectric effect can be explained without localized photons is reexamined and found to have been flawed in predicting no time delay for photoelectron emission; this accords with Millikan's conclusion (based upon energy conservation) that a classical plane wave would entail a delay prior to emission of the order of hours. The quantification of Einstein's localized packet concept as a solitary wave one wavelength in length (one period long in time) predicts a delay of one period of the photon's oscillating field, which accords with the experimentally measured response time being a few femtoseconds.
The photon is modeled as a monochromatic solution of Maxwell's equations confined as a soliton wave by the principle of causality of special relativity. The soliton travels rectilinearly at the speed of light. The solution can represent any of the known polarization (spin) states of the photon. For circularly polarized states the soliton's envelope is a circular ellipsoid whose length is the observed wavelength (λ), and whose diameter is λ/π;
this envelope contains the electromagnetic energy of the wave (hν = hc/λ). The predicted size and shape is confirmed by experimental measurements: of the sub-picosecond time delay of the photo-electric effect, of the attenuation of undiffracted transmission through slits narrower than the soliton's diameter of λ/π, and by the threshold intensity required for the onset of multiphoton absorption in focussed laser beams. Inside the envelope the wave's amplitude increases linearly with the radial distance from the axis of propagation, being zero on the axis. Outside the envelope the wave is evanescent with an amplitude that decreases inversely with the radial distance from the axis. The evanescent wave is responsible for the observed double-slit interference phenomenon.
A computational process is classified according to the theoretical model that is capable of executing it; computational processes that require a non-predeterminable amount of intermediate storage for their execution are Turing-machine (TM) processes, while those whose storage are predeterminable are Finite Automation (FA) processes. Simple processes (such as traffic light controller) are executable by Finite Automation, whereas the most general kind of computation requires a Turing Machine for its execution. This implies that a TM process must have a non-predeterminable amount of memory allocated to it at intermediate instants of its execution; i.e. dynamic memory allocation. Many processes encountered in practice are TM processes. The implication for computational practice is that the hardware (CPU) architecture and its operating system must facilitate dynamic memory allocation, and that the programming language used to specify TM processes must have statements with the semantic attribute of dynamic memory allocation, for in Alan Turing’s thesis on computation (1936) the “standard description” of a process is invariant over the most general data that the process is designed to process; i.e. the program describing the process should never have to be modified to allow for differences in the data that is to be processed in different instantiations; i.e. data-invariant programming. Any non-trivial program is partitioned into sub-programs (procedures, subroutines, functions, modules, etc). Examination of the calls/returns between the subprograms reveals that they are nodes in a tree-structure; this tree-structure is independent of the programming language used to encode (define) the process. Each sub-program typically needs some memory for its own use (to store values intermediate between its received data and its computed results); this locally required memory is not needed before the subprogram commences execution, and it is not needed after its execution terminates; it may be allocated as its execution commences, and deallocated as its execution terminates, and if the amount of this local memory is not known until just before execution commencement, then it is essential that it be allocated dynamically as the first action of its execution. This dynamically allocated/deallocated storage of each subprogram’s intermediate values, conforms with the stack discipline; i.e. last allocated = first to be deallocated, an incidental benefit of which is automatic overlaying of variables. This stack-based dynamic memory allocation was a semantic implication of the nested block structure that originated in the ALGOL-60 programming language. AGLOL-60 was a TM language, because the amount of memory allocated on subprogram (block/procedure) entry (for arrays, etc) was computable at execution time. A more general requirement of a Turing machine process is for code generation at run-time; this mandates access to the source language processor (compiler/interpretor) during execution of the process. This fundamental aspect of computer science is important to the future of system design, because it has been overlooked throughout the 55 years since modern computing began in 1048. The popular computer systems of this first half-century of computing were constrained by compile-time (or even operating system boot-time) memory allocation, and were thus limited to executing FA processes. The practical effect was that the distinction between the data-invariant program and its variable data was blurred; programmers had to make trial and error executions, modifying the program’s compile-time constants (array dimensions) to iterate towards the values required at run-time by the data being processed. This era of trial and error computing still persists; it pervades the culture of current (2003) computing practice.