My Best Teaching Is One-on-One


Of course, I team teach and do special lessons, etc.


But my best work in the classroom is after the lesson is over --
going one-on-one,
helping individual students with their assignments.


It's kind of like with computer programs, walking the client through hands-on.
The job isn't really done until the customer is using the program.


Saturday, November 24, 2012

First programmer?

My wife asked me and my son to change some carpet that had two desks and a chest of drawers on it. I was not enthusiastic, my son even less so. Took two hours or so, moving the furniture around in a Japanese apartment with limited space.

My son was making quite a bit of fuss about the imposition on his time, so I mentioned that computer programming often has a similar sort of problem to solve -- updating or changing software underneath live data in a limited space without damaging things, with minimum interruption to access.

My wife heard that and asked a very interesting question.

Who was the first programmer? Do we know?

One standard answer to that is Ada Lovelace, Charles Babbage's correspondent. From what I have read, I would include Babbage as well, and lean towards calling their work an early example of what we now call "pair programming".

Babbage's differential and analytic engines are said to be the first known devices in which direct corollaries to the elements of modern computers are found. However, they are not the first mechanical computers. As I have tried to demonstrate elsewhere, computing devices have been in use for all of recorded history, and some probable examples pre-date our extant records.

The engineers and artisans who have created these devices built programs into their structure. The diameter of a cog, with the number of teeth and their position, the lengths and orientations of rods and levers, the structure and design of these devices constitute their programs. Thus, Da Vinci was a programmer. Those who constructed astrolabes were programmers, and I would include the designers of Stonehenge.

Re-programmability is not the only yardstick of computing devices, nor is it required for a programmer to do his or her job.

Babbage is said to have conceived his differential engines in response to perusing a table of logarithms with known errors. That table was prepared with the assistance of a computer system, but the computers in the system were humans, computer being, in essence, a task or job title. A mathematician with advanced understanding formulated a series of simple steps which less skilled mathematicians followed to construct the tables.

Defining the steps and coordinating the system were essentially programming tasks. (And humans are definitely re-programmable in this sense, for what it's worth.)

With this concept in mind, we can safely say that any specification of a first programmer, short of God, Himself, is arbitrary.

Sunday, November 18, 2012

Software patent limitations

Let's set aside, for the moment, the arguments about software being maths (because too many people are confused by the mathematicians' argument that the whole world is nothing but mathematics).

[Update: I've started a separate blog for this kind of stuff.]

Patents in the physical realm have something that software patents, in their current state, do not have.



Included devices.

Yeah, limitations.

If we allowed physical patents like the current version of software patents, we'd have patents claiming "materials that have property P" or "materials that perform function F"; claiming "structures that look like S", "structures that perform function F", or "structures that have property P"; claiming "the inclusion of device D", or "devices that look like S", or "devices that perform function F", or "devices that have property P". Etc.

Those who love freedom make a lot of noise about patents on ideas. We'll set those arguments aside for a moment, too.

Surely we can see the problems here. If this kind of patent were allowed, the first patent on any device that reproduced sound would have covered every device that reproduced sound.

Can't you see that?

First, "This patent claims a device that records a physical representation of sound by capturing audio vibrations via a large membrane moving a needle to cut a groove in some plastic medium." paired with, "This patent claims a device that reproduces sound by transferring vibrations recorded in some plastic medium to a physical membrane."

(Don't forget that "plastic" means something besides poly-urethane here.)

These claims would already have been over-broad. (Compare them with history -- think about cylinders vs. discs.)

But the following claims would also have been allowed, most likely in the same patent.

"This patent claims a device that records any representation of sound in any media." paired with, "This patent claims a device that reproduces sound recorded in any media."

Had these claims been allowed, who would have owned the recording industry?

Lock, stock, and barrel. No, broader than that, even.

The courts are trying to restrict these kinds of patents, but they have no guides.

(Perhaps because too many lawyers who conflate maths with human laws have gotten stuck on the software-is-maths argument, drawing the wrong conclusion. The universe is mathematical, but no human has ever yet been able to define the grand unifying theory. The best general theories we have at present are so convoluted they would be subject to patent under the current patent regime -- if we allow software patents in their current form.)

Patents must, absolutely must have some reasonable limitations to be useful. In physical realm patents, materials, structures, included devices, etc., provide the basis for limits. They prevent the patenting of ideas.

(Okay, I snuck that back in. After I showed one of the many problems with patenting ideas, even complicated ideas. So sue me. Wait, someone is likely to do exactly that, so I should set pejorative aside, as well.)

What would be the parallel in software patents? If we absolutely have to have them. (And I think we probably do, at least until we can get our society freed of the atrocity that is the Berne Convention.)

What would provide the basis for limitation?

Source code.

Programming language provides a parallel to materials.

Modules, both physical and program, provide a parallel to included devices. Thus, the libraries linked in, the run-time environment assumed in the compiler, the compiler itself, the operating system, and the physical CPU and peripherals, all those implementation details presently only waved at by the phrase, "implemented in a computer device" provide essential parts of the missing basis for limitation.

("Implemented in which computer device?", for the sake of all that stands before the court.)

And the source code itself is the equivalent of blue-prints, diagrams, methods of assembly, etc. The source code itself is an essential limiting element, and so often missing, except for some symbolic pseudo-code or programming scrap freed from any actual implementation.

Pseudo-code must be unacceptable as a limiting element in patents. You can say anything you want in pseudo-code, because a human gets to figure out the implementation details later. Pseudo-code provides no basis for limitation.

A software patent absolutely must provide compilable source code, and it must be limited by the source code provided, bugs and all. And limited by the compiling environment and the target execution environment, OS specifics and hardware specifics, etc.

All the details of workable implementation, without which, even a very competent computer scientist is hard pressed to reproduce the subject of the patent. Including compilable source code.

These are the missing limitations in the current versions of software patents, and, until we deal with them properly, software patents cannot fail to provide us with an unworkable legal mess.