Computerprogrammierung für jedermann

Dies ist der Text eines überarbeiteten Finanzierungsvorschlags, den wir im August 1999 an die DARPA geschickt haben. Im März hörten wir, dass zumindest eine frühere Version des Vorschlags von der DARPA angenommen wurde; die Arbeit begann Ende 1999 und wird hoffentlich zwei Jahre dauern, obwohl wir nur für das erste Jahr Mittel erhalten haben (bis Oktober 2000). Wir halten die Daumen für den Rest.

Leider bedeutete der Wechsel des Python-Entwicklungsteams zu anderen Arbeitgebern, dass wir das CP4E-Projekt am CNRI nicht abschließen konnten. Dieser Schritt wurde zu einem großen Teil durch die enttäuschend geringe Summe finanziert, die die DARPA für CP4E zugesagt hatte.

Das Projekt ist nun in der Schwebe; IDLE wird weiterhin entwickelt, aber wir verfolgen die anderen Ziele von CP4E nicht aktiv. Andere tun dies jedoch; dies wird allgemein in der Mailingliste EDU-SIG diskutiert.

Hinweis: Ich habe eine Änderung am Text des Vorschlags vorgenommen: Auf Wunsch einiger Unterstützer anderer Sprachen habe ich eine Vergleichstabelle der Sprachen zurückgezogen, die sehr persönliche und manchmal unbegründete Meinungen über andere Sprachen enthielt. Die Tabelle wurde aus dem Kontext gerissen und auf eine Weise verwendet, die einige als anstößig empfanden. (Nicht die gesamte Tabelle ist strittig, aber es scheint ratsamer, keine direkten Sprachvergleiche ohne wesentlich mehr Dokumentation anzustellen.)

Ich habe auch einige administrative Details aus dem Text entfernt und einige kleinere Änderungen vorgenommen, um HTML zu berücksichtigen. Ich entschuldige mich für den Schreibstil, der zuweilen eher typisch für Finanzierungsvorschläge ist als für die meiste Prosa, die ich schreibe. Ich möchte Jeremy Hylton, Barry Warsaw, Al Vezza, Bob Kahn, Randy Pausch und David Beazley für ihre Beiträge und Vorschläge danken, die diesen Vorschlag zu einem Erfolg gemacht haben.

--Guido van Rossum

Weitere Ressourcen finden Sie auf den folgenden Seiten

• Python in Education Special Interest Group (EDU-SIG)
• IDLE - Pythons eigene interaktive Entwicklungsumgebung
• DARPA-Vorschlag - wo alles begann
• Diskussion über CP4E in Wards ursprünglichem Wiki.

Innovationsansprüche

In den Siebzigern fragte Xerox PARC: "Können wir einen Computer auf jedem Schreibtisch haben?" Wir wissen jetzt, dass dies möglich ist, aber diese Computer haben ihre Benutzer nicht unbedingt ermächtigt. Heutige Computer sind oft unflexibel: Der durchschnittliche Computerbenutzer kann typischerweise nur eine begrenzte Anzahl von Optionen ändern, die über einen "Assistenten" (ein hochtrabendes Wort für einen vordefinierten Dialog) konfigurierbar sind, und ist für alles andere von erfahrenen Programmierern abhängig.

Wir stellen eine weiterführende Frage: "Was passiert, wenn Benutzer ihren eigenen Computer programmieren können?" Wir freuen uns auf eine Zukunft, in der jeder Computerbenutzer "die Motorhaube" seines Computers öffnen und Verbesserungen an den darin enthaltenen Anwendungen vornehmen kann. Wir glauben, dass dies die Natur von Software und Softwareentwicklungswerkzeugen grundlegend verändern wird.

Wir vergleichen die Massenfähigkeit, Software zu lesen und zu schreiben, mit der Massenalphabetisierung und prognostizieren ebenso durchdringende gesellschaftliche Veränderungen. Die Hardware ist jetzt ausreichend schnell und billig, um Massencomputerbildung zu ermöglichen: Die nächste große Veränderung wird eintreten, wenn die meisten Computerbenutzer das Wissen und die Macht haben werden, Software zu erstellen und zu modifizieren.

Die Open-Source-Bewegung behauptet, dass die Peer-Review von Software durch Tausende die Qualität von Software erheblich verbessern kann. Der Erfolg von Linux zeigt den Wert dieser Behauptung. Wir glauben, dass der nächste Schritt, nämlich Millionen (oder Milliarden) von Programmierern, eine Veränderung anderer Qualität bewirken wird - die reichliche Verfügbarkeit personalisierter Software.

Die Werkzeuge, die für diese neue Sichtweise auf das Programmieren benötigt werden, werden sich von den Werkzeugen unterscheiden, die derzeit für professionelle Programmierer verfügbar sind. Wir beabsichtigen, sowohl das Schulungsmaterial als auch die verfügbaren Entwicklungswerkzeuge erheblich zu verbessern. Beispielsweise sollten sich Nicht-Fachprogrammierer nicht davor fürchten müssen, dass ein kleiner Fehler ihre Arbeit zerstören oder ihren Computer unbrauchbar machen könnte. Sie benötigen auch bessere Werkzeuge, die ihnen helfen, die Struktur eines Programms zu verstehen, sei sie explizit oder im Quellcode impliziert.

Unser Plan hat drei Komponenten:

• Entwicklung eines neuen Computerkurrikulums, das für Schüler der Mittel- und Oberstufe sowie Studenten geeignet ist.
• Erstellung besserer, einfacher zu bedienender Werkzeuge für die Programmentwicklung und -analyse.
• Aufbau einer Benutzergemeinschaft rund um all dies, Förderung von Feedback und Selbsthilfe.

Wir beabsichtigen, mit Python zu beginnen, einer Sprache, die für die schnelle Entwicklung konzipiert ist. Wir glauben, dass Python eine großartige erste Sprache zum Lernen ist: Im Gegensatz zu Sprachen, die speziell für Anfänger entwickelt wurden, ist Python auch die Wahl vieler Programmierprofis. Sie hat eine aktive, wachsende Benutzergemeinschaft, die bereits großes Interesse an diesem Vorschlag geäußert hat, und wir erwarten, dass dies ein fruchtbarer erster Einsatzbereich für die Lehrmaterialien und Werkzeuge sein wird, die wir zu erstellen vorschlagen. Im Laufe der Forschung werden wir Python evaluieren und Verbesserungen oder Alternativen vorschlagen.

Begründung

CNRI schlägt vor, eine Forschungsinitiative namens Computer Programming for Everybody (CP4E) durchzuführen. Diese Initiative zielt darauf ab, den Stand der Computernutzung zu verbessern, nicht durch die Einführung neuer Hardware oder gar (hauptsächlich) neuer Software, sondern einfach durch die Befähigung aller Benutzer, Computerprogrammierer zu werden.

Jüngste Entwicklungen in der Computer- und Kommunikationstechnologie haben vielen Menschen Zugang zu leistungsfähigen Computern in Form von Desktops, Laptops und eingebetteten Systemen verschafft. Es ist an der Zeit, diesen Benutzern durch Bildung und unterstützende Software mehr Kontrolle über ihre Computer zu geben. Wenn Benutzer ein allgemeines Verständnis von Computern auf dem Niveau von Software-Design und -Implementierung haben, wird dies zu einem massiven Anstieg von Produktivität und Kreativität führen, mit einer weitreichenden Auswirkung, die kaum vorhergesehen oder vorgestellt werden kann.

Kurzfristig werden die Menge und Qualität der verfügbaren Computersoftware drastisch verbessert, da die Vorstellungskraft und die Arbeit von Millionen auf das Problem angewendet werden. Erfinderische Benutzer werden in der Lage sein, die Software zu verbessern, die sie bei ihren Aufgaben unterstützt, und ihre Verbesserungen mit ihren Kollegen oder - über das Internet - mit anderen, weit entfernten Personen, die mit denselben Aufgaben und Problemen konfrontiert sind, zu teilen. Die Fähigkeit, Software zu ändern oder anzupassen, ist in Krisensituationen wichtig, wenn Experten nicht um Hilfe gebeten werden können. Sie ist auch für alltägliche Aktivitäten wichtig: Die Anzahl unbesetzter Programmierstellen wird von einigen derzeit auf 200.000 bis 400.000 geschätzt.

Forschungsziele

Die beiden Hauptforschungsziele sind die Entwicklung eines Prototyps eines neuen Programmierlehrplans und einer passenden Prototyp-Software, die eine hochgradig benutzerfreundliche Programmierumgebung umfasst. Wir stellen uns vor, dass das typische Zielpublikum Schüler der Mittel- und Oberstufe sowie Studenten (nicht-informatischer Hauptfach) sind, obwohl auch jüngere Schüler und Erwachsene berücksichtigt werden. Kurs und Software werden normalerweise zusammen verwendet, daher sollten sie eng aufeinander abgestimmt sein; jeder wird auch eigenständig nutzbar sein.

Wir werden auch die Rolle der Programmierung in der Zukunft untersuchen. Wir treten schnell in ein Zeitalter ein, in dem Informationsgeräte, tragbare Computer und tief vernetzte, eingebettete CPUs in Alltagsgegenständen den Benutzern die Kontrolle über ihre physische und informationelle Umgebung geben. Endbenutzerprogrammierbarkeit wird der Schlüssel zur Erschließung des Potenzials dieser Technologien sein. (Dies ist ein häufiges Thema der Information Technology Expeditions der DARPA, vgl. [Dertouzos].)

Die Forschungsarbeit wird nicht im Alleingang erfolgen. Wir werden akademische Forschungsgruppen sowie mehrere führende High Schools einbeziehen. Wir werden auch eine größere Gemeinschaft aufbauen, indem wir unsere Kursmaterialien und Software kostenlos im Internet zur Verfügung stellen.

Wir planen, zunächst beide Komponenten auf Python zu basieren, einer beliebten kostenlosen interpretierten objektorientierten Sprache [Python] [Lutz] [Watters]. Ursprünglich in Amsterdam am CWI entwickelt, wird Python derzeit von CNRI entwickelt und gepflegt. Python ist äußerst gut für Lehrzwecke geeignet, ohne eine "Spielzeugsprache" zu sein: Sie ist bei Computerprofis als Sprache für die schnelle Anwendungsentwicklung sehr beliebt. Python kombiniert Elemente aus mehreren wichtigen Programmierparadigmen (prozedural, funktional und objektorientiert) mit einer eleganten Syntax, die die Augen schont und leicht zu lernen und zu verwenden ist. Obwohl wir glauben, dass Python ein guter Ausgangspunkt ist, werden wir zweifellos feststellen, dass Verbesserungen möglich sind. Im Rahmen unserer Forschung werden wir die Wirksamkeit von Python für die Bildung und den Gebrauch durch Anfänger bewerten und Verbesserungen oder Alternativen entwerfen.

Wir erwarten, dass die Früchte unserer Forschung innerhalb von zwei Jahren demonstriert werden können und die Gesellschaft als Ganzes innerhalb eines Jahrzehnts beeinflussen können. Dies ist der Zeitpunkt, an dem Kinder, die Computerprogrammierung mit unserem Kurs in der High School lernen, in die Arbeitswelt (und das Militär) eintreten werden. Wir erwarten, dass die oben genannten neuen mobilen und eingebetteten Computer- und Kommunikationstechnologien um die gleiche Zeit ausgereift sein werden. Somit passen unsere Zeitpläne gut zusammen.

Motivation

In den dunklen Zeitaltern besaßen nur diejenigen mit Macht oder großem Reichtum (und ausgewählte Experten) Lese- und Schreibkenntnisse oder die Fähigkeit, diese zu erwerben. Man kann argumentieren, dass die Alphabetisierung der breiten Bevölkerung (obwohl immer noch nicht 100%) zusammen mit der Erfindung der Drucktechnologie eine der emanzipatorischsten Kräfte der modernen Geschichte war.

Wir sind erst vor kurzem in das Informationszeitalter eingetreten, und es wird erwartet, dass die Computer- und Kommunikationstechnologie den Druck bald als dominierende Form der Informationsverteilungstechnologie ersetzen wird. Etwa die Hälfte aller US-Haushalte besitzt bereits mindestens einen Personal Computer, und diese Zahl wächst weiter.

Während jedoch viele Menschen heutzutage einen Computer benutzen, sind nur wenige von ihnen Computerprogrammierer. Nicht-Programmierer sind nicht wirklich "ermächtigt", wie sie ihren Computer nutzen können: Sie sind darauf beschränkt, Anwendungen so zu nutzen, wie es "Programmierer" für sie bestimmt haben. Man muss kein Visionär sein, um die Grenzen hier zu erkennen.

Eine noch radikalere Veränderung ist die Einführung von Computing und Kommunikation, die in Heim- und Bürosystemen integriert sind. Die Anzahl der Geräte, die programmierbare Elemente enthalten werden, wird voraussichtlich in den kommenden Jahren dramatisch steigen. Wir müssen lernen, diese Programmierbarkeit für Benutzer sinnvoll zugänglich zu machen und es für Nicht-Programmierer einfach zu machen, diese Geräte zu steuern und zu programmieren.

Auf dieser "Expedition in die Zukunft" wollen wir die Vorstellung untersuchen, dass praktisch jeder ein gewisses Maß an Computerprogrammierkenntnissen in der Schule erwerben kann, so wie er lesen und schreiben lernt.

Es gibt viele Herausforderungen für Programmiersprachen und -umgebungen, die von einem Massenpublikum genutzt werden sollen. Wenn jeder ein Programmierer ist, werden sicherlich viele schlechte Programmierer dabei sein. Die angemessene Bewältigung dieser Situation erfordert ein Umdenken der grundlegenden Eigenschaften von Programmiersprachen und Entwicklungswerkzeugen. Dennoch glauben wir, dass es keinen klaren Unterschied zwischen Werkzeugen für Profis und Werkzeugen für die Bildung geben sollte - genauso wie professionelle Schriftsteller die gleiche Sprache und das gleiche Alphabet verwenden wie ihre Leser!

Angesichts der immer weiter verbreiteten Nutzung von Computern und Software in allen Bereichen der Gesellschaft erwarten wir, dass der Bedarf an Programmierkenntnissen nur steigen wird. Während die meiste hochwertige Software von Profis produziert wird, wird es einen Bedarf an mehr Programmierung und Anpassung durch Endbenutzer geben.

Beispiele für diesen Drang nach Flexibilität sind sowohl im gegenwärtigen Computing als auch in seiner wahrscheinlichen Zukunft zu sehen

• Immer leistungsfähigere Anwendungen für Desktop- und Laptop-Computer nutzen Skript- und Makrofunktionen.
• Das Wachstum des Internets hat direkt zu einem größeren Bedarf an Programmierbarkeit geführt, um aktive und interaktive Webinhalte zu erstellen.
• Endbenutzer-Informationsgeräte und Netzwerke von CPUs, die in alltägliche Geräte eingebettet sind - beide werden Benutzerkontrolle und Personalisierung erfordern.
• Mobile und intelligente Software-Agenten werden alltäglich sein und erfordern eine Anpassung durch Benutzer.

In Zukunft stellen wir uns vor, dass Computerprogrammierung in der Grundschule unterrichtet wird, wie Lesen, Schreiben und Rechnen. Wir meinen wirklich Computerprogrammierung - nicht nur Computernutzung (was bereits unterrichtet wird). Das Logo-Projekt [Papert][Logo] zum Beispiel hat gezeigt, dass kleine Kinder von einer Computerbildung profitieren können. Natürlich werden die meisten Kinder nicht zu erfahrenen Anwendungsentwicklern heranwachsen, genauso wie die meisten Menschen keine professionellen Autoren werden - aber Lese- und Schreibkenntnisse sind für jeden nützlich, und so werden es (in unserer Vision) auch allgemeine Programmierkenntnisse sein. Vorerst setzen wir unsere Ziele etwas weniger ehrgeizig. Wir konzentrieren uns auf das Lehren von Programmierung für High School- und (nicht-informatische Hauptfach) College-Studenten. Wenn wir hier erfolgreich sind, erwarten wir, dass die unteren Klassen bald folgen werden, innerhalb ihrer Grenzen.

Zusätzlich zum Ziel, zu lehren, wie Computer funktionieren, wird ein Kurs in Computerprogrammierung dem Lehrplan wieder einen Schwerpunkt auf logisches Denken zurückgeben, was einst der Hauptvorteil des Geometrieunterrichts war.

Zwei allgemeine Computing-Trends von besonderem Interesse sind die Hinwendung zu Informationsgeräten und das Wachstum von eingebetteten CPUs in alltäglichen Maschinen und Geräten - sei es im militärischen oder zivilen Sektor. Die abnehmende Größe von Computern und die zunehmende Reichweite von Netzwerken, insbesondere drahtlosen Netzwerken, ermöglichen den Informationsaustausch zwischen Geräten und die Interaktion mit ihnen. Die Fähigkeit zu programmieren wird die Fähigkeit der Benutzer, diese Geräte zu steuern, erheblich verbessern. Stellen Sie sich vor, Benutzer könnten ihre eigenen Änderungen an der Software vornehmen, die z.B. in ihrem GPS-Empfänger oder Handheld-Organizer eingebettet ist, anstatt (oder zusätzlich zu) dem Herunterladen von Updates von einem Anbieter oder dem Kauf von "fertigen" Zusatzanwendungen von Drittanbietern. Dies würde die Menschen erheblich befähigen, ihr Leben zu verbessern, indem sie ihre persönlichen Werkzeuge so programmieren, dass sie genau das tun, was sie brauchen.

Wenn wir erfolgreich sind, werden Nicht-Experten ihre Computer und andere intelligente Geräte wesentlich effektiver nutzen können, wodurch ihr Frustrationsniveau sinkt und ihre Produktivität und Arbeitszufriedenheit steigt. (Neue Freizeitmöglichkeiten werden zweifellos auch entstehen!) Computerbenutzer werden ihre Computerprobleme öfter selbst lösen können, wodurch die Notwendigkeit von technischem Support reduziert wird.

Selbst wenn die meisten Benutzer nicht regelmäßig programmieren, werden sie durch die Vertrautheit mit der Programmierung und der Struktur von Software zu effektiveren Benutzern von Computern. Wenn zum Beispiel etwas schief geht, werden sie ein besseres mentales Modell des wahrscheinlichen Fehlers machen können, was es ihnen ermöglicht, das Problem zu beheben oder zu umgehen. Sie werden auch besser einschätzen können, wann sie die Änderungen selbst vornehmen können und wann sie die Dienste eines Experten benötigen. Sie werden besser in der Lage sein, mit Experten zu kommunizieren, da sie nun eine gemeinsame Sprache teilen. Eine Analogie ist die Grundkenntnis der Automobilwartung: Sie wissen genug, um Ihr Öl zu überprüfen und ein paar Liter nachzufüllen, wenn nötig, aber Sie wissen auch, dass Sie nicht versuchen sollten, Ihre eigenen Bremsen zu wechseln. Wenn der Mechaniker sagt "Ihre Bremsscheiben sind verzogen und Sie brauchen neue Beläge", verstehen Sie, wovon er spricht.

Wenn diese Bemühung erfolgreich ist, könnte es viele Millionen, schließlich Milliarden von Computerprogrammierern verschiedener Kompetenzstufen geben. Die Auswirkungen auf den Stand der Softwareentwicklung sind schwer vorstellbar. Die Natur der Software wird sich ändern, um den Bedürfnissen dieser Programmierer Rechnung zu tragen, und die Anpassung durch Quellcode-Modifikationen ermöglichen - und Personalisierungen werden reichlich vorhanden sein.

Die Bemühung könnte auch einen großen Einfluss darauf haben, Frauen und Minderheiten für die Computerprogrammierung zu gewinnen - derzeit sind diese Gruppen stark unterrepräsentiert.

Die kürzlich beliebte Open-Source-Bewegung [OpenSource] verspricht, die Qualität wichtiger Softwarepakete durch die Peer-Review von Tausenden zu verbessern, sowie die Möglichkeit für Programmierer, "ihren eigenen Juckreiz zu kratzen" (d.h. die Software auf geringfügige Weise zu modifizieren, die nur eine Person interessiert). Wir erwarten, dass der Übergang von Tausenden zu Millionen oder Milliarden von Programmierern die Art des Softwareentwicklungsprozesses weiter verändern wird. Persönliches Programmieren wird in diesem Maßstab wichtiger (und machbarer) werden, während die Massen-Peer-Review relativ weniger wichtig wird, aufgrund abnehmender Erträge (die Logistik der Integration von Fehlerkorrekturen aus Tausenden von Quellen ist bereits eine gewaltige Aufgabe). Aber die meisten aktuellen Software, ob Open Source oder nicht, ist zu komplex, um es jemandem zu ermöglichen, persönliche Anpassungen vorzunehmen, ohne zuerst erhebliche Anstrengungen und Zeit in das Verständnis der verwendeten Software zu investieren. Wir interessieren uns für Änderungen am gesamten Softwareentwicklungsprozess, die auch dies beheben - insbesondere Entwicklungswerkzeuge.

Darüber hinaus werden wir durch die Ermöglichung der Programmierbarkeit von Anwendungen durch jedermann Skaleneffekte nutzen, ohne den Wunsch der Benutzer nach hochgradig personalisierter Software zu opfern. Anwendungen können massenhaft produziert werden, ohne dass jeder gezwungen ist, in seiner Nutzung der Software dem gleichen Muster zu folgen (oder nur in die von den Entwicklern geplanten Nischen der Anpassbarkeit). Benutzer werden ihre Systeme aus einer Reihe von Gründen personalisieren wollen; dazu gehören Produktivitätssteigerung, die Lösung eines spezifischen Problems oder einfach nur der Ausdruck ihrer Kreativität und die Abgrenzung von ihren Kollegen. Sie werden dies erreichen können, wenn sie die grundlegende Programmierkenntnis besitzen, die wir uns vorstellen.

Herausforderungen

Einige übergreifende Fragen helfen, unsere spezifischen Forschungsziele zu formulieren, wie zum Beispiel: Wird die in Schulen unterrichtete Programmiersprache den Programmiersprachen ähneln, die wir heute kennen? Wird sie überhaupt eine Programmiersprache genannt werden? Wie werden wir sie unterrichten? Wird es nur eine Sprache geben? Welche anderen Werkzeuge sind für den Unterricht und die Nutzung dieser Sprache unerlässlich? Ist es überhaupt möglich, eine Sprache und Werkzeuge zu haben, die sowohl für den Unterricht gut als auch für Experten nützlich sind?

Ebenso interessant sind Fragen wie diese: Wie und zu welchen Zwecken werden die Menschen ihre Programmierkenntnisse nutzen? Wie wird eine nahezu universelle Fähigkeit, Computerprogramme zu lesen und zu schreiben, die Struktur und den Nutzen von Computersoftware verändern? (Dies ist besonders interessant in Kombination mit zukünftigen Versionen des Internets, die Hochgeschwindigkeits-Ubiquitous-Zugang zu Computer- und Speicherelementen versprechen.) Werden die Leute motiviert sein, ihre Systeme tatsächlich zu programmieren, sobald sie das Vertrauen haben, dass sie es können? Werden sie überhaupt interessiert sein?

Ein klares Anliegen ist die Erwartung, dass, wenn die meisten Menschen Programmierer sind, viele von ihnen höchstwahrscheinlich *schlechte* Programmierer sein werden. Menschen, die in ihrer Muttersprache keine verständlichen Sätze schreiben oder ihre Schecks nicht ausgleichen können, werden wahrscheinlich keine gut strukturierten Computerprogramme schreiben! Unsere Absicht ist jedoch, die Programmierung für alle zugänglich, wenn nicht sogar einfach zu machen. Einige Benutzer werden externe Programmier- und Anpassungsdienste in Anspruch nehmen oder beauftragen. Das ist ähnlich wie ein Hausbesitzer, der einen Umbau beauftragt.

Wir müssen daher Wege untersuchen, um die Qualität der Interaktion zwischen dem Programmierer und dem System zu verbessern, um auch schlechten Programmierern zu helfen, das Beste aus ihren Computern herauszuholen. Man möchte zum Beispiel ein Programm schreiben, um sein PDA oder seinen Toaster anzupassen, könnte aber entmutigt sein, wenn ein kleiner Fehler sein Adressbuch löschen oder sein Haus in Brand setzen könnte. Schutzmaßnahmen gegen Katastrophen sind ebenso erforderlich wie Möglichkeiten, unerwünschte Änderungen an einem System als Ganzes rückgängig zu machen. ("Rückgängig" ist zwar sehr leistungsfähig, gilt aber normalerweise nur für eine Datei gleichzeitig. Das Rückgängigmachen unerwünschter globaler Systemänderungen erfordert typischerweise einen Neustart oder sogar eine schmerzhafte Datenwiederherstellung von Sicherungsmedien.)

Ein weiteres Anliegen betrifft das Konfigurationsmanagement. Ohne überlegenes Konfigurationsmanagement werden Unternehmen entweder nicht in der Lage sein, Probleme zu beheben, oder sie werden von Programmierern in Geiselhaft genommen, die das Betriebssystem oder Anwendungen so modifiziert haben, dass weder ein Upgrade noch andere Änderungen möglich sind. Im Allgemeinen laufen alle lokal vorgenommenen Änderungen an großen Softwaresystemen derzeit Gefahr, mit zukünftigen Upgrades des Hauptprodukts inkompatibel zu sein. Selbst lokal erstellte Software kann unbrauchbar werden, wenn der Hauptentwickler geht, aus einer Reihe von Gründen, einschließlich mangelnder Tests oder Dokumentation.

Abgesehen von der Angst, dass etwas schief gehen könnte, ist eine weitere Sorge für Anfänger, die daran interessiert sind, ihren Computer anzupassen, die entmutigende Aufgabe, ein großes Stück bestehende Software zu verstehen. Wir müssen uns benutzerfreundliche Werkzeuge zur Programmanalyse ansehen; mehr dazu später. Eine weitere intellektuelle Herausforderung ist die Visualisierung von (anwendungsgenerierten) Daten auf eine Weise, die Anfängern hilft. Tabellenkalkulationen sind hier von großem Wert, aber nicht alle Daten passen in die Matrixform.

Skriptsprachen werden unter professionellen Programmierern immer beliebter [Ousterhout], aber es bleiben Fragen zu Leistung, Wiederverwendbarkeit von Software und Integration mit Komponenten, die in anderen Sprachen geschrieben wurden. Wir können diese Herausforderungen angehen, indem wir die Funktionalität von JPython [Hugunin1], einem nahtlos mit Java integrierten Python-Dialekt, und SWIG, einem Interface-Generator, der Schnittstellen zwischen Skriptsprachen und Systemsprachen wie C oder C++ erstellt, erweitern.

Warum eine "allgemeine" Programmiersprache lehren?

Es ist allgemein anerkannt, dass es eine Art Dichotomie zwischen "allgemeinen" Programmiersprachen einerseits und "domänenspezifischen" Sprachen andererseits gibt. Für diese Diskussion verwenden wir den Begriff "allgemein" in einem breiten und lockeren Sinne, um funktionale Programmiersprachen und möglicherweise sogar logische Programmiersprachen einzuschließen, in dem Umfang, in dem sie als allgemeines Programmierwerkzeug nutzbar sind. Turing-Vollständigkeit ist hier das Schlüsselkonzept.

Die domänenspezifische Kategorie enthält dann alles andere, von der Syntax von Kommandozeilenargumenten bis hin zu E-Mail-Headern und HTML. Der Unterscheidungsfaktor hier ist das Vorhandensein einer relativ engen Anwendungsdomäne. In diese Kategorie fallen auch Dinge wie Microsofts "Assistenten" (eigentlich nur Sequenzen von vordefinierten Dialogen, die durch einfache Flussdiagramme verbunden sind) und die Bedienelemente und Schalter von Mikrowellenöfen oder Kernreaktoren.

Ein typisches Merkmal domänenspezifischer Sprachen ist, dass sie eine ausgezeichnete Kontrolle in der Anwendungsdomäne bieten, für die sie bestimmt waren, und (fast) keine Freiheit in unvorhergesehenen Bereichen. HTML zum Beispiel hat keine inhärente Fähigkeit zur bedingten Aufnahme von Text oder zur variablen Expansion. (Die Tatsache, dass solche Funktionen viele Male als inkompatible Erweiterungen hinzugefügt wurden, beweist nur diesen Punkt.)

Allgemeine Sprachen hingegen sind in einem bestimmten Bereich normalerweise nicht so gut. Zum Beispiel ist es viel schwieriger, einen Text in einer allgemeinen Sprache zu formatieren, als es in HTML ist. Allgemeine Sprachen machen dies jedoch durch ihre Turing-Vollständigkeit wett, die es ermöglicht, *jedes* Problem zu lösen, das auftreten mag (vorausgesetzt, ausreichende Ressourcen sind verfügbar). Allgemeine Sprachen sind daher ideal, wenn sie in *Kombination* mit domänenspezifischen Sprachen verwendet werden.

Wenn zum Beispiel Mobiltelefone programmierbar wären, würde man immer noch die reguläre domänenspezifische Schnittstelle (die Tastatur) verwenden, um eine bestimmte Nummer zu wählen, da dies der bequemste Weg ist, auf diese spezielle Funktionalität zuzugreifen. Ohne Programmierbarkeit gibt es jedoch keine Möglichkeit, zu versuchen, mehrere verschiedene Nummern für einen bestimmten Freund anzurufen, bis eine beantwortet wird, es sei denn, der Mobiltelefonanbieter hat diese spezielle Funktion vorhergesehen.

Warum mit Python beginnen?

Wir schlagen vor, zunächst die Programmierung in Python, einer bestehenden Skriptsprache, zu ermöglichen und uns auf die Erstellung einer neuen Entwicklungsumgebung und von Lehrmaterialien dafür zu konzentrieren. Wir haben anekdotische Beweise dafür, dass Python eine gute Sprache ist, die als erste Programmiersprache gelehrt werden kann. Unsere Bemühungen werden sich auf die Erstellung von Werkzeugen und Lehrmaterialien für diesen Zweck und auf die Förderung einer Community um diese Materialien konzentrieren. Dies wird es uns ermöglichen zu untersuchen, in welcher Weise Python eine gute (oder schlechte) Sprache zum Lehren ist, und Richtungen für die zukünftige Entwicklung vorzugeben.

Warum mit einer bestehenden Sprache beginnen? Unsere Erfahrung zeigt, dass das Design und die Implementierung einer neuen Sprache Jahre dauert - und dass diese Arbeit (fast) abgeschlossen sein muss, bevor eine benutzerfreundliche Entwicklungsumgebung und Lehrmaterialien erstellt werden können. Wir starten unser Projekt also mit einer bestehenden Sprache. Abhängig vom Benutzerfeedback können wir im Laufe des Projekts Änderungen an Python vornehmen oder eine neue Sprache komplett neu entwerfen.

Wir haben bereits einige Hinweise darauf, wo Änderungen notwendig sein könnten. Prof. Randy Pausch von der Carnegie Mellon University (siehe unten) hat einige Usability-Studien von Python in ihrem begrenzten Problembereich durchgeführt. Ihre Benutzer schienen am meisten durch die Groß- und Kleinschreibung von Python-Variablennamen und durch die Kürzung der Ganzzahldivision verwirrt zu sein. Umfassendere und verallgemeinerte Studien werden dazu dienen, spezifische Änderungen an Python vorzunehmen oder die Notwendigkeit einer neu konzipierten Sprache aufzuzeigen.

Python ist eine gute Sprache, um absolute Anfänger zu unterrichten. Sie leitet viele ihrer kritischen Funktionen von ABC ab, einer Sprache, die speziell für die Vermittlung von Programmierung an Nicht-Experten entwickelt wurde [ABC] [Geurts]. Die Python-Community hat viele Berichte von Personen erhalten, die ihre Kinder mit Python Programmieren beigebracht haben. Der Konsens aus diesen Berichten ist, dass die Sprache selbst für diesen Zweck gut geeignet ist - im Gegensatz zu z.B. C++, Java, Perl, Tcl oder Visual Basic, die mit Eigenheiten überladen sind.

Tabelle 1 auf der nächsten Seite ist eine (hoch subjektive) Tabelle, die einige relevante Aspekte von Python mit einigen anderen Sprachen vergleicht. Aus dieser Tabelle (und unserer Erfahrung) schließen wir, dass Python eine gute *erste Wahl* zum Lehren ist, die sich auch gut als Sprache für ernsthaftere Anwendungsentwicklung eignet. Im Gegensatz zu anderen für Anfänger vorgeschlagenen Sprachen (z.B. Logo, LogoMation, sogar Pythons Vorläufer ABC) ist Python nicht *nur* eine Lehrsprache. Sie eignet sich für die Entwicklung großer realer Anwendungen, wie Projekte hier bei CNRI [Knowbots] [Mailman] sowie anderswo zeigen. Zum Beispiel hat Industrial Light and Magic seine gesamte Werkzeugbasis auf Python umgestellt und betrachtet dies als Vorteil gegenüber der Konkurrenz.

Darüber hinaus ist Python durch Module erweiterbar, die in anderen Sprachen (z.B. C, C++ oder Java) geschrieben sind, um den Zugriff auf erweiterte Funktionalität zu vermitteln, die von Python aus nicht direkt zugänglich ist (z.B. leistungsstarke 3D-Computergrafikpakete). Obwohl wir nicht erwarten, dass Studenten diese Erweiterungsmodule schreiben, macht die *Verwendung* solcher Module es möglich, ihre Lernerfahrung erheblich aufzuwerten. Diese Erweiterbarkeit gibt Lehrern die Möglichkeit, Lektionen an die Interessen ihrer Schüler anzupassen, indem sie ihnen einen geschützten Zugang zu anderen Softwarepaketen bieten.

Die Tatsache, dass Python zur Entwicklung großer Anwendungen verwendet werden kann, spielt in einen anderen Aspekt unserer Vision hinein, nämlich die Entwicklung von Open-Source-Anwendungssoftware, die von Benutzern, die keine erfahrenen Programmierer sind, aber einige Programmierkenntnisse erworben haben, angepasst werden kann. Obwohl dies nicht der Schwerpunkt unserer Bemühungen hier ist, hoffen wir, dass wir zumindest einige Initiativen in diese Richtung sehen werden, und wir werden Unternehmen und Organisationen ermutigen, die Schritte in diese Richtung unternehmen möchten. Wir erwarten, dass die Existenz von JPython hier ein wichtiger Ermöglicher sein wird.

Die Programmierumgebung und Dokumentation von Python sind für Anfänger weniger ideal. Insbesondere die bestehenden Werkzeuge zur Programmentwicklung und Tutorials für Python (es gibt mehrere von jedem) gehen davon aus, dass der Benutzer ein gestandener Entwickler ist, der eine Reihe externer Werkzeuge zum Bearbeiten, Ausführen und Debuggen von Programmen kennt und bereits eine oder mehrere andere Programmiersprachen und deren Entwicklungsumgebungen beherrscht. Dies steht derzeit einer breiteren Verbreitung von Python als erster Programmiersprache im Wege.

Ansatz

Wir werden eine Programmierumgebung der nächsten Generation und Lehrmaterialien erstellen, die es normalen Benutzern ermöglichen, einfache Programme zu schreiben und die Struktur und Organisation größerer Programme zu verstehen. Wir werden auch untersuchen, wie sich weit verbreitete Programmierkenntnisse auf die Produktion und Nutzung von Software in einer ubiquitären Computing-Umgebung auswirken werden.

Unsere Arbeit ist in drei Bereiche unterteilt

• ein neuer Computerkurs, der für Schüler der Oberstufe und Studenten geeignet ist.
• bessere, benutzerfreundlichere Werkzeuge für die Programmentwicklung und -analyse.
• eine Benutzergemeinschaft, die sich um das Vorherige bildet und Feedback sowie gegenseitige Hilfe fördert.

Sobald erste Versionen des neu entwickelten Kurses und der Werkzeuge an die Community freigegeben werden, werden die Feedback-Kanäle geöffnet. Das anfängliche Feedback wird hauptsächlich in Verbesserungen der Umgebung und des Lehrmaterials fließen. Hier beginnt der Aufbau der Community.

Kursentwicklung

Ein Hauptziel der CP4E-Bemühungen ist die Entwicklung eines Curriculums zur Vermittlung von Programmierkenntnissen an eine Vielzahl von Studenten, von Studenten, die keine Hauptfächer in Informatik belegen, bis hin zu Schülern der Sekundarstufe und schließlich auch der Grund- und Mittelstufe. Der Ansatz für jede dieser Altersstufen kann unterschiedlich sein, um die Schüler besser zu erreichen und an sie anzuknüpfen, wenn sie reifen, aber CP4E strebt einen einheitlichen Ansatz an, der mit dem Schüler wächst und im Laufe der Zeit reichhaltigeres und tiefergehendes Themenmaterial präsentiert. Die anfänglichen Bemühungen werden sich hauptsächlich auf Schüler der Oberstufe und Studenten konzentrieren.

CNRI wird die grundlegenden Materialien für das Curriculum entwickeln, einschließlich Software, die in den Lehrmaterialien verwendet wird, sowie Tutorials und einführendes Material, das als Grundlage für Lehrbücher über Programmierung dienen kann. CNRI wird eng mit Pädagogen zusammenarbeiten, die Erfahrung in der Erstellung von Lehrbüchern und anderen Lehrmaterialien haben, um diese Werkzeuge bestmöglich auf die beabsichtigten Altersgruppen zuzuschneiden.

Unser Ziel ist es, die Softwareumgebungen und -werkzeuge, die von erfahreneren Programmierern verwendet werden, zu nehmen und Versionen davon zu produzieren, die für die Vermittlung von Programmierkenntnissen nützlich sind. Wir lassen uns vom bestehenden interaktiven Python-Interpreter und von IDLE (einer grafischen Entwicklungsumgebung für Python) inspirieren, die beide entweder als Produktivitätstools für professionelle Programmierer oder als Lehrmittel in Verbindung mit Tutorial-Material verwendet werden können. Unsere neuen Werkzeuge bieten nützliche Funktionalität für Anfänger und erfahrene Programmierer gleichermaßen.

Neuer Computerkurs

CNRI schlägt vor, mit der University of Chicago zusammenzuarbeiten, um einen neuen Kurs in Informatik zu entwickeln, bei dem Python als Programmiersprache für alle Ebenen des Programmierunterrichts verwendet wird. Python ist eine besonders geeignete Sprache für diesen Zweck, da sie leicht zu erlernen, zu lesen und zu verwenden ist und dennoch leistungsfähig genug, um wesentliche Aspekte von Programmiersprachen und Software-Engineering zu veranschaulichen. So könnten auch junge Schüler die Grundlagen der Programmierung mit Python erlernen, wären aber in ihrem Anwendungsbereich nicht so eingeschränkt wie mit Logo. Die Verwendung von Python würde es jedem Schüler ermöglichen, in seinem eigenen Tempo zu erkunden und Fortschritte zu machen. Besonders aufregend ist die Tatsache, dass begabte Schüler eine leistungsfähige Programmiersprache und Umgebung bereits zur Verfügung hätten, falls sie motiviert wären, mehr oder schneller zu lernen.

Die University of Chicago würde eine Reihe von Kursen entwickeln, die Studenten ohne Hauptfach Informatik auf Bachelor- und High-School-Niveau in Programmierung und Computerkonzepte einführen. Derzeit betonen Kurse auf diesem Niveau entweder Programmiersprachen (mit einem starken mathematischen Schwerpunkt) oder Web-Programmierungsthemen wie HTML und JavaScript. Leider haben beide Ansätze ernsthafte Einschränkungen. Wenn ein Kurs übermäßig formal und mathematisch ist, spricht er möglicherweise nur Informatikstudenten und Studenten mit technischem Hintergrund an. Auf der anderen Seite konzentrieren sich Web-Programmierkurse zwar stark auf die Popularität des Internets, aber oft eng auf spezifische Technologien wie HTML, Perl oder JavaScript. Infolgedessen lernen die Studenten wenig über Informatik in einem größeren Kontext oder erwerben die Problemlösungsfähigkeiten, die zur Lösung zukünftiger Rechenprobleme erforderlich sind.

Der in Chicago zu entwickelnde Kurs wird die Aspekte der Informatik behandeln, von denen wir glauben, dass jeder sie kennen muss, um ein sachkundiger Computerbenutzer zu sein

• Grundlegende Computerorganisation. Die Schüler lernen die Grundlagen, wie Computer funktionieren und wie sie aufgebaut sind. Themen wären Boolesche Algebra, Logik und einfache Computerarchitektur (z. B. CPU, Speicher, E/A). Einfach ausgedrückt, dies ist das Zeug, das „unter der Haube“ passiert – einfach ausgedrückt in leicht verständlichen Begriffen. Letztendlich hoffen wir, Computer so weit wie möglich zu entmystifizieren.
• Eine Einführung in die Programmierung. Diese führt verschiedene Wege ein, auf denen Menschen Computer programmiert haben. Die Studenten lernen prozedurale, funktionale und objektorientierte Programmierung, aber auf informelle Weise. Anstatt zu versuchen, die Studenten in professionelle Programmierer zu verwandeln, wird das Ziel darin bestehen, die Studenten mit einigen der Methoden vertraut zu machen, mit denen versucht wurde, die Nutzung von Computern zu vereinfachen.
• Softwarearchitektur. In Zukunft werden Computer zunehmend dadurch programmiert, dass bestehende Softwarekomponenten zusammengesetzt und eine kleine Menge Kleber-Code geschrieben wird. Um dies zu ermöglichen, ist ein Verständnis dafür, wie Software zusammengesetzt wird, unerlässlich. Studenten lernen etwas über Softwaredesign und Softwareorganisation (was um alles in der Welt sind diese DLLs überhaupt?).
• Debugging und Problemlösung. Wie man überlebt, wenn alles andere fehlschlägt – ohne den Kundendienst anrufen zu müssen.

3D-Spiel

Wir beabsichtigen, uns selbst an kleinen Lehrinitiativen zu beteiligen, z. B. an den lokalen High Schools, die im Abschnitt „Zusammenarbeit“ aufgeführt sind, aber wir erwarten nicht, dass wir viel lehren werden. Wenn unsere Erfahrung mit der Popularität von Python ein Indikator ist, werden wir das nicht tun müssen: Andere sind bestrebt, an diesem Experiment teilzunehmen.

Die Kurse werden die im nächsten Abschnitt beschriebene neue Entwicklungsumgebung verwenden. Als Anreiz, Programmieren „lustiger“ zu gestalten, beabsichtigen wir, die Entwicklungsumgebung mit einer bestehenden programmierbaren 3D-Spiel-Engine zu verbinden, wie sie in beliebten Computerspielen verwendet wird. Mehrere solcher Engines sind oder werden wahrscheinlich für die Verwendung mit Python verfügbar sein; wir werden eine auswählen und eine geeignete Schnittstellenbibliothek für unser Publikum erstellen.

Warum eine 3D-Spiel-Engine verwenden? Die Erfahrungen mit Logo zeigen, dass Grafiken eine gute Möglichkeit sind, die Aufmerksamkeit eines jüngeren Publikums zu fesseln, aber ihre 2D-Grafiken sehen im Vergleich zu den Videospielen, mit denen Teenager heute vertraut sind, etwas langweilig aus. Alice ist ein gutes Beispiel für eine ansprechende 3D-Grafikumgebung.

Knowbot-Programme

Zusätzlich zur Verwendung eines 3D-Spiels als Testumgebung können wir die Knowbot-Technologie von CNRI [Knowbots] als motivierende Anwendung für unerfahrene Programmierer nutzen. Knowbot-Programme sind unabhängige, mobile Programme, die zwischen Knowbot-„Service-Stationen“ (speziell ausgestattete Hosts) im Internet wandern können. Service-Stationen bieten den Knowbot-Programmen Dienste wie Suchdienste, digitale Objektarchive, Auktionsdienste usw.

Eine andere Sichtweise auf ein Knowbot-Programm ist die eines kleinen Bausteins innerhalb des größeren Rahmens der Service-Station. Ein Knowbot-Programm ist ein modulares, unabhängiges Programm, das leicht geschrieben werden kann, um sich im Internet zu bewegen, aber leistungsstarke Funktionalität durch seine Integration in den Rahmen und die Nutzung der Umgebungen, denen es begegnet, besitzt.

Wir werden verschiedene Ideen untersuchen, wie Knowbot-Programme im Lehrplan eingesetzt werden können. Wir stellen uns kooperative Spielszenarien vor, bei denen Studenten Knowbot-Programme mit bestimmten Verhaltensweisen erstellen und gemeinsam ein gemeinsames Problem lösen müssen. Dies wäre eine großartige Möglichkeit, Studenten aus dem gesamten Internet zur Zusammenarbeit zu motivieren.

Wir könnten Schatzsuchen konzipieren, bei denen die Studenten die gerade erlernten Programmierkenntnisse anwenden müssen, um eine Service-Station zu entdecken und zu ihr zu migrieren, dort ein Rätsel zu lösen und den Schatz zu erhalten. Wir könnten verteilte virtuelle Simulationen entwerfen, ähnlich dem Virtual Fishtank von MIT [Fishtank], bei denen Studenten ihre eigenen diskreten Elemente eines komplexen Systems erstellen können (z. B. einen virtuellen Fisch in einem Knowbot-Programm implementieren) und beobachten, wie ihre eigenen Elemente mit anderen interagieren. Da die Knowbot-Technologie hochgradig verteilte, sehr komplexe Interaktionen im gesamten Internet ermöglicht, bietet sie uns eine einzigartige Plattform für Experimente mit reichhaltigen kooperativen Lernmöglichkeiten.

Programmierwerkzeuge

Wir werden eine Programmierumgebung entwerfen und bauen, die speziell für die Vermittlung des Programmierens an Benutzer ohne vorherige Programmiererfahrung konzipiert ist. Unser Ziel ist es, Werkzeuge bereitzustellen, die Benutzer beim Erlernen des Programmierens unterstützen und wenn sie diese Fähigkeiten zu Hause und im Büro anwenden.

Wir glauben, dass die meisten normalen Benutzer ihre Programmierkenntnisse nutzen werden, um ihre Computing-Umgebung anzupassen und zu erweitern. Anstatt neue Programme von Grund auf neu zu schreiben, werden die meisten Leute neuen Code zu bestehenden Programmen hinzufügen. Es gibt drei wesentliche Herausforderungen, denen sich Programmierwerkzeuge für dieses Publikum stellen müssen.

Erstens muss die Umgebung den Aufwand für das Schreiben, Installieren und Debuggen neuer Programme erheblich reduzieren. Die aktuelle Generation von Entwicklungswerkzeugen kann für erfahrene Benutzer umständlich sein, ganz zu schweigen von Anfängern. Wir müssen sorgfältiges Design und Usability-Studien auf die Entwicklung neuer Programmierumgebungen konzentrieren.

Die zweite Herausforderung besteht darin, die kontinuierliche Weiterentwicklung und Modifikation von Softwareartefakten durch Verbraucher und Produzenten zu ermöglichen. Wir werden Werkzeuge entwickeln, die Benutzern helfen, die Struktur großer Programme zu verstehen, damit sie identifizieren können, wo Änderungen vorgenommen werden müssen und welche Auswirkungen diese Änderungen haben werden. Unsere Werkzeuge werden Benutzern auch helfen, Software zu verwalten und zu konfigurieren, damit einzelne Komponenten im Laufe der Zeit ersetzt oder aktualisiert werden können. Diese Werkzeuge werden Benutzern helfen, neue und modifizierte Programme zu teilen, indem sie automatisch Versionen und Abhängigkeiten verfolgen.

Die letzte Herausforderung besteht darin, Werkzeuge zu bauen, die in einer ubiquitären Computing-Umgebung nützlich sind. Die Desktop-Computing-Umgebung wird schnell von Netzwerken computergesteuerter Geräte und physischer Systeme überrannt werden. Diese neue Umgebung verschärft die Probleme bei der Installation, dem Debugging und der Verwaltung von Software. Sie stellt auch neue Herausforderungen für Systemdesigner dar, Software zu erstellen, die eine Anpassung durch den Endbenutzer ermöglicht.

Dieser Abschnitt ist um diese drei Herausforderungen herum organisiert. Der erste Abschnitt diskutiert die vorgeschlagene Programmierumgebung. Der zweite Abschnitt behandelt Werkzeuge zur Programm-Analyse und Konfigurationsverwaltung. Der dritte Abschnitt behandelt Anwendungsframeworks zur Unterstützung der Endbenutzer-Programmierbarkeit von ubiquitären Computing-Umgebungen.

Unser Ansatz für dieses Problem wird darin bestehen, zu untersuchen, wie traditionelle Programmierwerkzeuge wie Editoren, Debugger und Klassenbrowser durch fortschrittlichere Methoden zur Analyse, Inspektion und zum Verständnis von Programmen ergänzt und verbessert werden können.

Programmierumgebungen

Die grundlegendsten Aktivitäten von Programmierern sind das Bearbeiten des Quellcodes, das Ausführen des Programms zum Testen und das Debuggen des Programms. (Python hat keine separate Kompilierungsphase.) Eine Programmierumgebung muss diese Aktivitäten natürlich unterstützen. Wir entwickeln eine portable Programmierumgebung für Python namens IDLE, die es dem Benutzer ermöglicht, einzelne Anweisungen interaktiv auszuführen. Sie richtet sich hauptsächlich an erfahrene Programmierer, wird aber als Ausgangspunkt für eine Umgebung für absolute Anfänger dienen.

IDLE kratzt nur an der Oberfläche der Art von Programmierumgebung, die benötigt wird, um unerfahrene Programmierer zu unterstützen. Zum Beispiel könnten seine Funktionen zur Quellcode-Farbgebung und Einrückung durch einen viel leistungsfähigeren Programmprüfer ersetzt werden, der alle Syntaxfehler, undefinierten Bezeichner, Typkonflikte usw. anzeigt, während der Benutzer tippt (ähnlich einem Rechtschreibprüfer). Der Debugger könnte das Zurückverfolgen von Ausführungsschritten, das Bearbeiten des Quellcodes des laufenden Programms usw. unterstützen. Der Programmeditor könnte eine flexible Form des vorlagenbasierten Bearbeitens unterstützen (die Alice-Gruppe hat sehr gute Erfahrungen damit in ihrem begrenzten Bereich). Die Rückgängig-Funktion, die derzeit nur Änderungen am Quellcode rückgängig macht, könnte erweitert werden, um Änderungen am Laufzeitzustand des Programms oder sogar Seiteneffekte auf die Umgebung rückgängig zu machen (in vernünftigem Rahmen – wir können nicht erwarten, das Drucken oder das Senden einer E-Mail rückgängig zu machen). Als Beispiel bietet die Alice-Software eine vollständige Rückgängig-Funktion für alle Aktionen, die Änderungen an der von ihr verwalteten 3D-Welt beinhalten.

Zwei spezifische Arbeitsbereiche sind Rückgängig machen und ein erweiterter Typenprüfer.

„Rückgängig machen“ ist ein äußerst wichtiges Werkzeug für Anfänger, da es die erste Verteidigungslinie des Programmierers ist. Zusammen mit Versionskontrolle, Autosave und anderen Funktionen bedeutet die Möglichkeit, eine unbegrenzte Anzahl von kurzfristigen Änderungen rückgängig zu machen, dass der Programmierer mehr Spielraum zum Experimentieren und Lernen hat. Die meisten Implementierungen für „Rückgängig machen“ sind jedoch in ihrem Umfang ziemlich begrenzt. Unser Ansatz wird Konzepte wie selektives und globales Rückgängigmachen untersuchen. In einem traditionellen Rückgängig-System behält der Editor einfach eine verknüpfte Liste von Änderungen an einer Datei, und diese Änderungen können durch Bewegung durch diese Liste rückgängig gemacht oder wieder angewendet werden (es gibt Variationen dieses Themas, einschließlich Rückgängig-Ringen und Rückgängig/Wiederholen). Eines der Probleme mit traditionellem Rückgängigmachen ist, wenn sich unerwünschte Änderungen mit wünschenswerten Änderungen überschneiden; der Programmierer muss oft die wünschenswerten opfern, um die unerwünschten zu beseitigen.

Beim selektiven Rückgängigmachen können Änderungen auf eine feinere Granularität lokalisiert werden. Angenommen, ein Programmierer hat drei Änderungen an Funktion A am Anfang der Datei vorgenommen, vermischt mit vier Änderungen an Funktion Z am Ende der Datei. Nun stellt der Programmierer fest, dass Funktion A niemals hätte geändert werden dürfen; selektives Rückgängigmachen ermöglicht es, Änderungen an Funktion A rückgängig zu machen, ohne die Änderungen an Funktion Z zu beeinträchtigen.

Globales Rückgängigmachen ähnelt dem, was Versionskontrolle bietet, bei der systemweite Änderungen markiert und rückgängig gemacht werden können, wenn sie sich negativ auf das System auswirken. Wo sich globales Rückgängigmachen jedoch unterscheidet, ist, dass keine vorherige Entscheidung über die Markierung getroffen werden muss.

Wir planen auch, die Entwicklungsumgebung mit Typenprüfwerkzeugen zu erweitern, die Programmierern helfen, Fehler in ihrem Code zu finden und die Leistung von kompiliertem Code zu verbessern. Python ist eine dynamisch typisierte Sprache wie Smalltalk oder Scheme, die auf umfangreiche Laufzeitprüfungen angewiesen ist, um die korrekte Verwendung von integrierten Operationen sicherzustellen. Soft Typing [Cartwright] ist ein Mechanismus zur statischen Überprüfung von Programmen in dynamisch typisierten Sprachen, um Fehler zu erkennen und unnötige Laufzeitprüfungen zu eliminieren; die Analyse ist in die Programmierumgebung und nicht in die Programmlaufzeit integriert. Dieser Mechanismus wurde auf Scheme angewendet [Wright][Flanagan]. Wir werden einen ähnlichen Typenprüfmechanismus für Python entwickeln. Die wichtigsten Herausforderungen bei der Entwicklung eines Soft-Typensystems für Python sind die Erweiterung der Analyse auf Objekte und Module sowie die Berücksichtigung der extrem dynamischen Ausführungsumgebung von Python, die die Modifikation von Klassen und Instanzen zur Laufzeit ermöglicht.

Vorläufige Arbeiten bei CNRI zeigten den Wert der Typanalyse zur Verbesserung der Leistung von JPython-Programmen. Hugunin [Hugunin2] demonstrierte Leistungssteigerungen von bis zu drei Größenordnungen für JPython.

Programm-Analyse und Konfigurationsmanagement

Wir werden die grundlegende Programmierumgebung um eine Sammlung von Werkzeugen ergänzen, die Benutzern beim Verstehen großer Programme helfen, damit sie diese anpassen und modifizieren können, und beim Verwalten der Installation und Konfiguration von Software, damit sie die Software aktualisieren können, ohne ihre Modifikationen zu zerstören. Wir werden auch Werkzeuge entwickeln und erweitern, die Schnittstellen zwischen Low-Level-Softwarekomponenten und Skriptsprachen erstellen, um eine größere Benutzerkontrolle über die Low-Level-Komponenten zu ermöglichen.

Es ist wichtig, dass diese Programm-Analysewerkzeuge, die sich an Anfänger richten, einfach zu bedienen sind und dass sie die Ergebnisse der Analyse *ohne* detaillierte Kenntnisse der Funktionsweise der Analyse erfassen lassen. Gleichzeitig streben wir danach, dass unsere Werkzeuge auch für Experten leistungsfähig genug sind – sie sollen zunehmende Expertenlevel berücksichtigen, wenn ein Benutzer mit dem Werkzeug vertrauter wird, und sie sollen in der Lage sein, große Programme zu verarbeiten. Ein Analysewerkzeug, das beispielsweise auf den Quellcode des Netscape-Browsers angewendet werden kann, ist weitaus nützlicher als eines, das nur für kleine Beispielprogramme gut funktioniert.

Unser Fokus auf relativ unerfahrene Programmierer erfordert, dass unsere Werkzeuge hervorragende Visualisierungsmodule enthalten, die dem Benutzer das entdeckte Design präsentieren können, ohne zu Informationsüberlastung zu führen. Aktuelle Visualisierungswerkzeuge fehlt es beispielsweise oft an „gesundem Menschenverstand“, und sie produzieren gedankenlos große Baum- oder Diagramme, die sich über viele Seiten erstrecken und aus sich endlos wiederholenden ähnlichen Teilstrukturen bestehen; dieser Effekt führt dazu, dass der Benutzer den Wald vor lauter Bäumen nicht mehr sieht.

Wir planen, uns zunächst auf Werkzeuge zu konzentrieren, die mit Python-Programmen arbeiten. Die meisten Techniken zur Programm-Analyse, die wir entwickeln werden, sind jedoch im Wesentlichen sprachunabhängig. Wir werden auch den Einsatz von Werkzeugen untersuchen, die Sprachgrenzen überschreiten, damit Benutzer die Auswirkungen von Änderungen auf Skriptsprachenebene auf Low-Level-Komponenten in C oder Java berücksichtigen können.

Die Programm-Analysewerkzeuge helfen Benutzern, die grobe Struktur von Programmen zu verstehen, indem sie die Beziehungen zwischen statischen Programmkomponenten identifizieren. Ein Beispiel für diese Art von Analysewerkzeug ist Womble, das Objektmodelle aus Java-Bytecodes extrahiert [Jackson]. Womble extrahiert Objektmodelle direkt aus Quellcode (oder Objektcode) und nicht aus einer formalen Spezifikation. Da diese Methode nicht auf der Existenz einer formalen Spezifikation (wie einem UML-Modell) beruht, glauben wir, dass sie für normale Benutzer zugänglicher ist. Ein ähnlicher Ansatz kann zur Analyse von Python-Programmen verwendet werden, obwohl Pythons dynamische Typisierung und „First-Class“-Funktionen und -Klassen erhebliche Herausforderungen darstellen.

Wir werden auch Program Slicing [Tip] und Program Paths [Ball] als Techniken untersuchen, um Benutzern zu helfen zu verstehen, wo Änderungen vorgenommen werden sollen und welche Auswirkungen diese Änderungen haben werden. Slicing ist eine bekannte Technik zur Identifizierung von Teilmengen von Programmen, die eine bestimmte Variable beeinflussen. Analyse über Programm-Pfade zeigt die verschiedenen möglichen Ausführungspfade durch einen Codebereich. Jede Technik hat Wert für das Testen und Debuggen von Programmen. Zwei Herausforderungen bestehen darin, diese Techniken sprachübergreifend anzuwenden und Abstraktionsgrenzen zu identifizieren, die implizit im Code vorhanden, aber durch das Typsystem ungenau ausgedrückt sind. Womble erkennt beispielsweise, dass Java-Containerklassen kein interessanter Teil des Objektmodells einer Anwendung sind; es repräsentiert lediglich eine Beziehung zwischen dem Objekt, das den Container verwendet, und den enthaltenen Objekten. Ebenso könnte ein Program Slice in Bezug auf bestimmte Abstraktionsgrenzen und Aspekte des Codes durchgeführt werden. Ein Program Slice, das den funktionalen Aspekt eines Programms präsentiert, ohne Nebenläufigkeits-spezifischen Code einzuschließen, kann nützlich sein, um die Programmstruktur zu verstehen. (Natürlich ist der Nebenläufigkeits-spezifische Code wichtig zu verstehen, kann aber ein separates Anliegen sein.)

Ein drittes Arbeitsgebiet ist die automatische Generierung von Skriptsprachen-Schnittstellen zu Low-Level-Code wie C, C++ oder Java. Das SWIG-Tool [SWIG], entwickelt von unserem Kollaborateur David Beazley (siehe Abschnitt „Zusammenarbeitspläne“ unten), hilft Benutzern, Skriptsprachen-Bindings aus C und C++ zu generieren. Wir werden daran arbeiten, SWIG zu verbessern und zu erweitern, um den Grad der automatischen Verarbeitung zu erhöhen und eine größere Anpassung der Bindings durch Benutzer zu ermöglichen. Wir werden SWIG auch erweitern, um natürlichere Sprachbindungen zu erzeugen; zum Beispiel werden bei der Übergabe von Zeichenketten als Funktionsparameter in C-Programmen typischerweise zwei Variablen verwendet: ein Zeiger und eine Länge. Die SWIG-Bindings sollten automatisch zwischen diesen beiden C-Variablen und einem einzelnen Python-String-Argument konvertieren.

Wenn Benutzer befähigt werden, Code zu modifizieren und anzupassen, werden sie vor der Herausforderung stehen, diese Änderungen zu pflegen, wenn die zugrunde liegende Software aktualisiert wird oder Systemkomponenten ersetzt werden. Versionskontrolle ist bereits ein heikles Problem für Softwareentwickler, die sicherstellen müssen, dass ihre Produkte mit vielen Betriebssystemen und gemeinsam genutzten Bibliotheken kompatibel sind. Benutzer werden auch ihre Anpassungen mit anderen teilen wollen – Kollegen oder Freunden und Verwandten. Wir werden Werkzeuge bereitstellen, die Benutzern helfen, Programme und Änderungen an Programmen zu pflegen und zu teilen.

Eines der wichtigsten Probleme, das unsere Forschung an Programmierwerkzeugen angehen wird, ist die Belastung, die die Benutzeranpassbarkeit für das Systemkonfigurationsmanagement mit sich bringt. Wenn ein Benutzer eine Änderung an einer Anwendung vornimmt, welche Zusicherungen gibt es, dass ein zukünftiges Update der Anwendung durch den Anbieter mit diesen Änderungen kompatibel sein wird? Wie behält der Benutzer selbst den Überblick darüber, welche Änderungen er an einer Anwendung vorgenommen hat? Was passiert, wenn eine zukünftige Version des Produkts eine zuvor fehlende Funktion hinzufügt, die der Benutzer hinzugefügt hat (in einer anderen Form)?

Unsere Werkzeuge werden Benutzern helfen, die von ihnen vorgenommenen Änderungen über aufeinanderfolgende Revisionen hinweg zu verfolgen und Benutzern helfen, ihre Änderungen zusammenzuführen, wenn die primäre Anwendung selbst vom Anbieter modifiziert oder aktualisiert wurde. Ein Schlüssel zu diesem Ansatz ist die Identifizierung jeder Softwareversion und eine einfache Sprache zur Beschreibung ihrer Eigenschaften und Abhängigkeiten. Zum Beispiel beabsichtigen wir, Versionskontrollsysteme so zu verbessern, dass sie Änderungen auf verschiedenen Abstraktionsebenen und Granularitäten verfolgen als aktuelle Systeme, z. B. indem sie Änderungen basierend auf den von ihnen implementierten Funktionen kennzeichnen, anstatt auf den Quellcodedateien (oder Teilen davon), die sie ändern. Das Werkzeug wird automatisch Abhängigkeiten von anderen Bibliotheken und Komponenten identifizieren. Wir werden Wege untersuchen, Test-Frameworks in die Konfigurationsmanagementsysteme zu integrieren, so dass bei einem Upgrade der primären Anwendung jede vom Benutzer installierte Feature-Änderung zusammengeführt und getestet wird.

Wir werden auch gemeinschaftsfördernde Werkzeuge erstellen, die das Teilen, Integrieren und Nutzen von von Peers entwickelter Software erleichtern. Zu behandelnde Themen sind Abhängigkeitsmanagement zwischen Paketen, einfache Installation (und Deinstallation!), Umgang mit Änderungen sowohl am Betriebssystem, an Anwendungen und Bibliotheken, Versionskontrolle und Paketwartung. Software muss beschrieben und klassifiziert werden, und Foren für Diskussionen, Feedback, Fehlerberichte und Patches (sowohl an den Maintainer als auch vom Maintainer) müssen eingerichtet werden. Von größter Bedeutung ist, dass diese gemeinschaftsbildenden Werkzeuge primär von der Gemeinschaft selbst verwaltet werden müssen; sie müssen hochgradig verteilt, repliziert und sicher sein. Zum Beispiel könnten Benutzer Informationen über Kompatibilitätsprobleme zwischen verschiedenen Bibliotheken austauschen; in Verbindung mit automatischen Verteilungswerkzeugen könnten diese Informationen Software-Upgrades verhindern, die andere Anwendungen daran hindern, zu funktionieren.

Es gibt mehrere bestehende Werkzeuge, die versuchen, einige oder alle dieser Probleme zu lösen. Das Comprehensive Perl Archive Network versucht, alle Perl-Materialien zu enthalten, die ein Perl-Programmierer jemals benötigen wird [CPAN]. Es ist verteilt und repliziert und erleichtert die Installation von Perl-Modulen (wenn auch nicht immer einfach genug). Es ist jedoch nicht sehr anpassungsfähig an andere Arten von Archivmaterial. Innerhalb der Python-Community versucht die Arbeitsgruppe „distribution-utilities“ die Distribution und Installation von Drittanbieter-Software zu erleichtern, befasst sich jedoch nicht mit den breiteren damit verbundenen Problemen und ist wiederum eng auf Python-Software fokussiert [Distutils]. Die ambitionierteste verwandte Arbeit, mit der wir vertraut sind, ist das Projekt „self-updating software“ [Liskov].

Anwendungsframeworks

Wir werden die Auswirkungen zukünftiger Veränderungen in Informatik und Kommunikation auf die Art und Weise untersuchen, wie Benutzer Computer steuern, und die Implikationen solcher Entwicklungen wie nahezu unendliche Bandbreite, größerer Zugang zu viel leistungsfähigeren Computern, der Ubiquität von Computerressourcen und einem viel höheren Grad an Vernetzung, selbst auf der Mikrogeräte-Ebene. Diese Veränderungen betreffen sowohl die Art von Programmen, die Benutzer schreiben werden, als auch die Art von Computern, auf denen diese Programme laufen werden.

Unser Ansatz in diesem Bereich wird darin bestehen, mit experimentellen und Prototypen-Systemen zu arbeiten, um zu verstehen, wie die Programmierbarkeit von Endbenutzern bereitgestellt werden sollte. Wenn diese Technologien reifen, können wir unsere Erfahrungen in Lehrmaterialien einfließen lassen.

Viele Nicht-Programmierer beginnen damit, kleine Programme zu schreiben, die in bestimmten Domänen und im Kontext von Anwendungsframeworks verwendet werden. Die Tabellenkalkulation ist vielleicht das beste Beispiel für Programmierung in einem begrenzten Kontext. Sie bietet eine begrenzte Sprache, die speziell auf die Manipulation von Tabellen mit numerischen Daten zugeschnitten ist. Die Anwendung bietet den Koordinationsrahmen – Verwaltung der Anzeige, des Kontrollflusses, E/A usw. – und lässt den Benutzer sich auf ein bestimmtes Problem konzentrieren. Eine Makrofunktion, die ein Teil der Programmiersuite einer Tabellenkalkulation ist, unterstützt die Nutzung vieler Anwendungen und ermöglicht es Benutzern, sich wiederholende Aufgaben zu automatisieren. Ein zweites Beispiel findet sich in MS Word Makros, die ebenfalls eine häufige Form der Benutzeranpassung darstellen.

Das Internet hat viele Nicht-Profis mit der Programmierung in Kontakt gebracht, insbesondere in domänenspezifischen Sprachen wie HTML und aktiven Inhalts-Sprachen wie JavaScript, PHP und CGI. Auch in diesen Situationen erstellen Nicht-Programmierer typischerweise kleine Programme, die in den größeren Kontext passen, zum Beispiel eines Webservers, der sich um Details wie die Verwaltung der TCP/IP-Verbindungen zu den Clients, die Einrichtung der Umgebung, in der die Benutzerprogramme ausgeführt werden, die Behandlung von Fehlersituationen und die Einhaltung von Standardprotokollen kümmert.

In Zukunft werden Nicht-Programmierer eine Fülle von Informationsgeräten nutzen. Ein Beispielbereich, in dem die Programmierbarkeit dieser Geräte ihre Nützlichkeit erheblich verbessern wird, ist die Verwaltung des Informationsflusses – und vielleicht entscheidender, die *Begrenzung* des Informationsflusses. Eine Person kann Nachrichten über viele Medien erhalten – Text, Sprache, Video – und diese über viele Geräte wie PDA, Mobiltelefon und Computerbildschirm abrufen. Wir erwarten eine nahtlose Interoperabilität, so dass beispielsweise ein Mobiltelefon verwendet werden kann, um eine E-Mail mit einer Sprachantwort zu beantworten, ohne die Nummer nachschlagen zu müssen. Kleine Programme könnten verwendet werden, um die Schnittstellen auf diesen Geräten anzupassen und den Nachrichtenfluss durch sie zu filtern und zu begrenzen.

Einige Beispiele sind

• Versuch, mehrere verschiedene Telefonnummern zu wählen, um eine Person zu erreichen, vielleicht je nach Tageszeit oder Wochentag.
• Umleitung eingehender Anrufe an Sprachnachricht oder E-Mail, wenn Sie nicht gestört werden möchten – aber wichtige Anrufe trotzdem durchlassen.
• Lautstärke von TV oder Radio reduzieren, wenn Sie den Hörer abheben.
• Aufnahme von Kopien bestimmter Anrufe, vielleicht durch Aufruf eines Sprach-zu-Text-Konverters.
• Begrenzung der Menge persönlicher Informationen, die im Rahmen einer E-Commerce-Transaktion an Geschäfte oder Unternehmen übertragen werden.

Diese Beispiele deuten auf ein wichtiges Muster im Programmierumfang hin: Benutzer werden Anwendungen und Geräte im Kontext des Rechenmodells und des Software-Frameworks des Systems anpassen. Daher wird unsere Expedition Möglichkeiten zur Modularisierung von Anwendungen untersuchen und diese Module so organisieren, dass Benutzer die kleinen Funktionsbausteine hinzufügen können, die sie wünschen, ohne sich mit dem Betrieb des gesamten Systems befassen zu müssen.

Eines der Hauptziele, Nicht-Programmierer zu befähigen, Software im Kontext von Anwendungsframeworks oder eingebetteten Geräten zu modifizieren und anzupassen, ist die Reduzierung der kognitiven Belastung, die erforderlich ist, um zu verstehen, wie die Modifikation in das größere Programm passt. Dies gilt auch für erfahrene Programmierer, die neu in der Codebasis einer Anwendung sind. Anwendungen müssen modular sein und ausreichend High-Level-Abstraktionen bieten, damit ihre Bestandteile schnell und unabhängig verstanden werden können. Dies ermöglicht es den Menschen, sich hauptsächlich auf die Teile zu konzentrieren, die geändert werden müssen. In unserem Ansatz werden wir mehrere Ideen untersuchen, die darauf abzielen, die Modularität von Software zu verbessern.

Wir beabsichtigen, bestehende Techniken wie objektorientierte Programmierung und Komponentenkomposition als Möglichkeiten zur Organisation der Software zu betrachten. Theoretisch ist es viel einfacher, eine Blackbox-Komponente durch eine andere Funktionalität auszutauschen, solange die Schnittstellen und die Ein- und Ausgabesemantik beibehalten werden. In der Realität ist es derzeit sehr schwierig, Klassen und Komponenten zu schreiben, die unabhängig vom Rest des Systems sind. Wir werden auch neue Konzepte wie Aspect Oriented Programming [AOP] untersuchen, eine neue Methode zur Modularisierung von Software basierend auf Querschnittsthemen. Vielleicht erweist sich eine Kombination dieser oder neuer Modularisierungstechniken als wirksam, zum Beispiel durch Organisation jeder Funktion als Aspekt einer Komponente.

Community-Aufbau

Neben der Zusammenarbeit mit ausgewählten Partnern werden wir die Beteiligung der breiten Öffentlichkeit suchen. Dies werden wir tun, indem wir Prototypen der entwickelten Kurse und Software über eine Website teilen und Feedback zu diesen Materialien über verschiedene Kanäle wie Newsgroups und Mailinglisten einholen. CNRI verfügt über beträchtliche Erfahrung mit der Beteiligung der Community über das Web und auf andere Weise. Zum Beispiel ist der Python-Website [Python] der zentrale Fokus für die Python-Community, die auch viele Python-bezogene Mailinglisten hostet; ein wichtiger Fokus für die Digital-Library-Community ist die D-Lib-Website [D-Lib]. Beide Seiten werden von CNRI betrieben. Die bestehende Python-Community zeigt bereits großes Interesse am CP4E-Vorschlag, und wir erwarten, dass dies der perfekte Ort sein wird, um Community-Aktivitäten speziell für die CP4E-Bemühungen zu starten.

Solche expliziten Einrichtungen zur Einbeziehung der Gemeinschaft werden unserer Forschung erheblich zugutekommen und es der Gemeinschaft ermöglichen, den größten Nutzen aus unserer Forschung zu ziehen. Vorteile der frühen und groß angelegten Einbeziehung der Gemeinschaft für unsere Forschung werden sein: Freiwillige, die helfen, unsere Kurse und Softwareprototypen „testzufahren“; neue Kurse, die von Community-Mitgliedern für spezifische Zielgruppen oder zur Vermittlung spezifischer Fähigkeiten oder Themen entwickelt werden; lokalisierte Varianten, Übersetzungen usw. bestehender Kurse; neue oder modifizierte Beispiele (man kann nie genug Beispiele haben, und Beispiele, die auf bestimmte Zielgruppen zugeschnitten sind, sind effektiver); neue Anwendungen, die von und für Studenten unserer Kurse unter Verwendung unserer Programmentwicklungssoftware entwickelt werden; und so weiter. In der Python-Community erhalten wir viele solcher Beiträge (einschließlich vollständiger fremdsprachiger Übersetzungen wichtiger Dokumente) völlig unaufgefordert!

Vorteile für die Community sind der frühe Zugang zu neuen Kursen und Software sowie die Unterstützung von Lehrern bei der Lehre und der Überzeugung ihrer Managementabteilungen von der Bedeutung der Vermittlung von Computerprogrammierung an alle Schüler (im Gegensatz zu den Leistungskursen). Wir erwarten auch, dass die vorgeschlagenen Gemeinschaftseinrichtungen ein hohes Maß an Eigenständigkeit bei den Gemeindemitgliedern fördern werden. So finden beispielsweise in Co-Tutoring-Projekten Schüler, die Nachhilfe benötigen, Freiwillige im Netz (oft fortgeschrittenere Schüler), und Lehrer können ihre Erfahrungen direkt austauschen. Diese Art von Nachhilfetätigkeit findet bereits in der Python-Community statt und hilft, die Belastung unseres Forschungsteams durch wiederholte Anfragen nach Hilfe bei einfachen Fragen zu verringern.

Im Geiste der "Massen-Computerkenntnisse" und der Open-Source-Bewegung [OpenSource] werden wir auf unserer Website Kurse und Software weit und kostenlos zugänglich machen. Neben der Website werden wir eine oder mehrere Mailinglisten mit Archiven und möglicherweise einen "Chat"-Dienst für Benutzer einrichten und pflegen. Wir werden uns aktiv an den Mailinglisten beteiligen, um eine Community zu fördern, und auch das Feedback sammeln und analysieren, das uns die Community über diese (und andere) Kanäle gibt.

Es ist klar, dass wir die Einbeziehung der Community für den Erfolg dieses Projekts für wesentlich halten. Daher wollen wir über die typische Website-Einrichtung hinausgehen. Wir planen, eine automatisierte Archivierungsseite für Lehrer, Schüler und Programmierer zu erstellen, die zum Austausch von Kursnotizen, Beispielen, nützlicher Software und so weiter genutzt werden kann. Wir planen auch, Prototyp-Software zu entwickeln, die Benutzer dabei unterstützt, konsistente Sammlungen von Softwarepaketen, sowohl lokal entwickelt als auch heruntergeladen, auf einem oder mehreren Rechnern zu verwalten. Der erwartete häufige Austausch von Erweiterungen, Upgrades, Patches, Benutzeranpassungen und so weiter würde mit der bestehenden Praxis zu einem Albtraum von Versionskontrollproblemen führen. Dies wird im obigen Unterabschnitt "Teilen und Verwalten" näher erläutert.

Kollaborationspläne

Wir werden in das Programm eine gewisse geplante Zusammenarbeit mit anderen akademischen und nicht-akademischen Institutionen einbauen, um den Erfolg der Forschung zu gewährleisten. Insbesondere schlagen wir vor, einige Aktivitäten an Gruppen der Carnegie Mellon University und der University of Chicago zu vergeben. Die Alice-Gruppe an der CMU hat Python erfolgreich als Endbenutzer-Programmiersprache für ihre beliebte Virtual-Reality-Software eingesetzt; die University of Chicago verfügt über erhebliche Erfahrung und Interesse an der Entwicklung von CS-Lehrplänen. Wir planen auch, informell mit anderen akademischen Gruppen zusammenzuarbeiten und die Teilnahme so weit wie möglich zu öffnen.

Carnegie Mellon University

Die Alice-Gruppe [Alice] [Pausch] unter der Leitung von Prof. Randy Pausch entwickelt erschwingliche 3D-Grafik- und Virtual-Reality-Software für Windows, ursprünglich an der University of Virginia und jetzt an der Carnegie Mellon University. Sie verwenden Python sowohl für die Endbenutzerprogrammierung als auch bei der Implementierung großer Teile ihres Systems (fast alles außer der Rendering-Engine). Sie verfügen wahrscheinlich über die umfangreichste und am besten dokumentierte Fallstudie über die Vermittlung von Python-Programmierung (wenn auch in einem begrenzten Bereich) an Benutzer ohne Vorkenntnisse, und ihre Begeisterung für Python hat uns sehr ermutigt, die Verwendung von Python in einem allgemeinen Programmierlehrplan in Betracht zu ziehen. Sie sind auch eine der wenigen Gruppen, die Usability-Tests auf Programmiersprachen und Application Programmer Interfaces anwendet.

Wir planen, die Alice-Gruppe mit begrenzten Mitteln zu unterstützen, um diesen Teil ihrer Forschung auf gegenseitig vorteilhafte Weise fortzusetzen. Wir erwarten, von ihren Erfahrungen bei der Vermittlung von Python an Anfänger, von den einfachen, aber effektiven Programmierwerkzeugen, die sie in das Alice-System integriert haben, und von ihrer Kompetenz im User-Testing zu profitieren – sehr wichtig für das Tutorial und die von uns geplante Software. Sie werden von unserem Tutorial (das Alice-Benutzern eine breitere Anleitung zur Softwareentwicklung bietet) sowie von unserer Software (leistungsfähigere Programmierwerkzeuge) profitieren.

University of Chicago

Die University of Chicago kann sich in zwei Kernbereichen in die CP4E-Forschungsarbeit einbringen: Lehrplanentwicklung und Softwareentwicklungswerkzeuge. Wir planen auch die Zusammenarbeit mit der University of Chicago Laboratory School, einer privaten K-12-Schule, die von der University of Chicago betrieben wird. Unser Ansprechpartner an der University of Chicago ist Prof. David Beazley, ein erfahrener Python-Benutzer. Wir planen, die University of Chicago mit begrenzten Mitteln für die Lehrplanentwicklung zu unterstützen. Dies wird uns zugutekommen, da sie Interesse und Erfahrung im Unterrichten haben; ihr Nutzen wird die Nutzung einer überlegenen Programmiersprache und von Werkzeugen sein.

Lokale Schulen

Schließlich planen wir, direkt mit ausgewählten lokalen Schulen zusammenzuarbeiten, um die entwickelten Materialien zu "testen". Die Zusammenarbeit mit lokalen Schulen ermöglicht regelmäßige persönliche Treffen mit Lehrern und Schülern; wir halten dies für wesentlich für die Bewertung unseres Prototyp-Kurses und unserer Software. Die Yorktown High School in Arlington County, Virginia, hat bereits Interesse an diesem Vorschlag gezeigt [Yorktown].

Ein weiterer möglicher Kandidat könnte die Thomas Jefferson High School for Science and Technology sein, eine öffentliche Magnetschule in Fairfax County, Virginia, die bereits einen Informatikunterricht für fortgeschrittene Schüler anbietet [TJHSST]. Wir werden während des Projektverlaufs auch andere lokale Schulen in Maryland, Virginia und im District of Columbia zur Zusammenarbeit kontaktieren.

Andere Forschungsgruppen

Wir planen auch die informelle Zusammenarbeit mit akademischen und anderen Forschungsgruppen, die Personal-Computing-Hardware und -Software für die Zukunft entwickeln ("Ubiquitous Computing"-Projekte); all diese Projekte sehen eine gewisse Endbenutzerprogrammierbarkeit vor. Einige Beispiele für solche Projekte sind Project Oxygen am MIT [Dertouzos], Portolano/Workscape an der Xerox PARC und der University of Washington [Portolano] sowie Invisible Computing an der CMU.

Wir gehen davon aus, dass der Hauptvorteil einer solchen Kooperation die frühe Einführung unserer Technologie in fortgeschrittenen Systemen sein wird, während ihr Vorteil die verbesserte Endbenutzerprogrammierbarkeit der von ihnen entwickelten Systeme sein wird. Beachten Sie, dass das Timing hier ausgezeichnet ist: Die weit verbreitete Einführung von persönlichen, eingebetteten Systemen, wie sie z.B. in Project Oxygen vorgesehen ist, wird etwa zur gleichen Zeit erwartet, zu der unser Lehrplan und unsere Software weit verbreitet sein könnten.

Vergleich mit anderer Forschung

ABC. Der Vorgänger von Python, ABC, wurde in den frühen Achtzigerjahren als Lehrsprache entwickelt. Sein Motto war "Basiskram ausrotten" – eine Anerkennung der damaligen Hauptkonkurrenz bei Sprachen für Nicht-Experten. Die Entwickler von ABC hatten viel Erfahrung im Unterrichten "klassischer" Programmiersprachen wie ALGOL für Anfänger. Sie stellten fest, dass ihre Schüler oft so überwältigt waren von den zufälligen Details der Verwendung einer Computersprache (wie dem Ausführen des Compilers, dem Umgang mit verschiedenen numerischen Formaten, obskuren E/A-Operationen und dem Low-Level-Speicher-Management), dass sie nie dazu kamen, sich auf die wesentlichen Aspekte eines guten Programm- und Algorithmusdesigns zu konzentrieren.

Um diesem Effekt entgegenzuwirken, gingen die Entwickler von ABC von Grundprinzipien aus. Sie entwarfen eine Sprache und eine Umgebung für diese Sprache, die sich um alle Nebensächlichkeiten kümmern sollte, damit der Schüler mehr Zeit hatte, das Wesentliche der Programmierung unabhängig von der jeweiligen Programmiersprache zu lernen, wie z.B. klaren Kontrollfluss und leistungsfähige Datenstrukturen, und sich auf die elegante Formulierung von Programmen zu konzentrieren. Sie schlugen sowohl ein neues Sprachdesign als auch eine neue Terminologie vor, die sich radikal von dem unterschied, was unter Informatikern und Programmierern üblich war (und immer noch ist). Tatsächlich ist der größte einzelne Grund, warum ABC nicht die erwartete Wirkung erzielte, wahrscheinlich, dass sie sich zu weit von der aktuellen Praxis abwendeten. Die Leute, die Zugang zu der benötigten Hardware für ABC hatten (anfangs lief es nur auf Unix-Systemen, obwohl es später auf den Mac und den PC portiert wurde), waren oft erfahrene Computernutzer, die frustriert waren, dass ABC nicht "die gleiche Sprache sprach" wie ihre anderen Anwendungen.

Etwa ein Jahrzehnt später entstand Python aus dieser Frustration. Es teilt ABCs Fokus auf Eleganz des Ausdrucks, Grundlagen der Programmierung und die Beseitigung von Nebensächlichkeiten, fügt aber Objektorientierung, Erweiterbarkeit und eine leistungsfähige Bibliothek von Modulen hinzu, die über viele verschiedene Mechanismen mit anderen Anwendungen verbunden sind: gemeinsame Dateien, Einbettung von Programmen, RPC-Schnittstellen wie CORBA oder COM und Netzwerkprotokolle (Unterstützung aller typischen Internetprotokolle).

Logo. Logo ist eigentlich eine Familie von Sprachen, die mit Lisp verwandt ist und größtenteils am MIT entwickelt wurde. Es ist natürlich die bekannteste Programmiersprache für Kinder. Es hat eine reiche Tradition, starke Wurzeln in Schulen und eine Reihe von kommerziellen Angeboten. Es gibt laufende Forschungsgruppen der Epistemology and Learning Group am MIT Media Lab, z.B. den "programmierbaren Baustein" (in Zusammenarbeit mit LEGO).

Ein wesentlicher Unterschied zwischen Logo und unserem Vorschlag liegt in unserer Vision, dass Millionen von (Amateur-)Programmierern gemeinsam Open-Source-Software entwickeln werden – Logo scheint sich damit zu begnügen, jüngeren Kindern begrenzte Programmierkenntnisse zu vermitteln, für die Computerprogrammierung hauptsächlich eine Möglichkeit ist, ihren Verstand im abstrakten Denken zu trainieren. Logo hat auch nur begrenzte Anwendbarkeit in der realen Softwareentwicklung.

LogoMation. Ein Unternehmen namens Magic Square verkauft LogoMation, eine Sprache, die Logo nicht unähnlich ist und einen ähnlichen Schwerpunkt auf Turtle-Grafik legt. Sie kommt mit einem ausgezeichneten Tutorial, das für Kinder ab 8 Jahren geeignet ist. Die Syntax von LogoMation ähnelt der von Python (mehr als die von Logo); das deutet darauf hin, dass wir mit Python auf dem richtigen Weg sind.

Aber wie Logo bietet LogoMation nur begrenzte Wachstumsmöglichkeiten. Es befasst sich nicht direkt mit der Frage "was als nächstes", und erwartet von seinen Benutzern, dass sie für echte Arbeit zu anderen Programmiersprachen wechseln.

Alice. Die Erfahrungsberichte auf der Alice-Website zeigen deutlich, dass Alice erfolgreich darin ist, Kindern und Erwachsenen ohne Computerkenntnisse Programmierung beizubringen. Sie zeigen auch die Bedeutung einer "lustigen" Umgebung (und die 3D-Grafiken von Alice sind attraktiver als die Turtle-Grafiken von Logo). Alice gibt uns auch einige Hinweise darauf, welche Aspekte von Python verbessert werden könnten: Zum Beispiel legen ihre Erfahrungen nahe, dass die Groß- und Kleinschreibung von Python ein Problem darstellt.

Der Schwerpunkt des Alice-Projekts liegt jedoch auf 3D-Grafiken – das Alice-Tutorial lehrt nicht wirklich viel in Bezug auf Programm- oder Datenstrukturierungstechniken. Während wir zustimmen, dass 3D-Grafiken eine großartige Möglichkeit sind, ein junges Publikum zu fesseln, sind wir mehr daran interessiert, Programmierung im Allgemeinen zu lehren, nicht nur Grafik. Aus diesem Grund liegt der Schwerpunkt unserer anfänglichen Arbeit auf der Entwicklung einer Programmierumgebung und eines Tutorials, in denen 3D-Grafiken nur eine von vielen Anwendungsmöglichkeiten eines Computers sind.

DrScheme. Das TeachScheme! Projekt an der Rice University [TeachScheme] zielt darauf ab, einen neuen Einführungskurs in Informatik auf der Grundlage der Programmiersprache Scheme zu entwickeln. Ein zentraler Bestandteil der Rice-Bemühungen ist die Entwicklung von DrScheme [Findler], einer Programmierumgebung für Anfänger. Der Schwerpunkt von TeachScheme liegt auf einem relativ engen Publikum – College-Studenten, die eine solide Grundlage in High-School-Algebra und Interesse an Informatik und deren Anwendung auf wissenschaftliche Probleme haben. Wir stellen uns ein viel breiteres Publikum vor, bei dem die Annahmen über eine starke mathematische Vorkenntnisse und Interesse an wissenschaftlichen Problemen nicht zutreffen. Wir gehen auch davon aus, dass Scheme, eine Sprache, die sich hervorragend zur Darstellung der grundlegenden Bausteine der Berechnung für pädagogische Zwecke eignet, für ein Massenpublikum ungeeignet wäre.

Interessant ist jedoch, dass ein Schlüsselteil des TeachScheme-Projekts eine Entwicklungsumgebung ist. Während die Zielgruppen und der Ansatz unterschiedlich sind, teilen unser Projekt und TeachScheme die Ansicht, dass die Entwicklungsumgebung eine entscheidende Komponente darstellt. Es besteht Bedarf an einer interaktiven Read-Eval-Print-Schleife, einem leistungsfähigen Debugger und Werkzeugen zum Verständnis der Funktionsweise von Programmen.

Einrichtungen

Wir werden die bestehende Computerinfrastruktur von CNRI für die Entwicklung und Verbreitung der vorgeschlagenen Materialien nutzen, ergänzt durch Desktop-Workstations und einen Webserver, die speziell für dieses Projekt angeschafft werden. Wir werden das Internet und das World Wide Web für die gesamte Verbreitung der Materialien nutzen.

Liste der Schlüsselpersonal

Guido van Rossum wird diese Anstrengung bei CNRI leiten. Er ist Gruppenleiter bei CNRI und der Schöpfer von Python, für das er weiterhin als Hauptentwickler tätig ist. Er ist auch der Hauptarchitekt des mobilen Agentensystems Knowbot. Zuvor arbeitete er an ABC, einer Programmiersprache, die zu Lehrzwecken entwickelt wurde, und an Amoeba, einem bekannten verteilten Betriebssystem aus den 80er Jahren. Er hat einen Master-Abschluss in Mathematik und Informatik von der Universität Amsterdam.

Jeremy Hylton ist leitendes Mitglied des technischen Personals von CNRI. Er ist einer der Architekten des mobilen Agentensystems Knowbot und hat mehrere agentenbasierte Informationsmanagementanwendungen entworfen und implementiert. Er erhielt 1996 einen M.Eng. in Elektrotechnik und Informatik sowie einen S.B. in Informatik und Ingenieurwesen vom Massachusetts Institute of Technology.

Barry Warsaw ist leitendes Mitglied des technischen Personals von CNRI. Er war beitragender Architekt an mehreren CNRI-Projekten, darunter das Application Gateway System, das Knowbot Operating Environment und JPython. Er hat zur Entwicklung der Sprache Python und des Grail Internet Browsers beigetragen. Er erwarb 1984 einen B.S. in Informatik von der University of Maryland. Vor CNRI arbeitete er von 1980 bis 1990 an Roboter-Operator-Schnittstellen am National Institute of Standards and Technology und von 1990 bis 1994 an medizinischer Datenbankinformationstechnologie an der National Library of Medicine.

Leistungsumfang

CNRI wird folgende Arbeiten ausführen:

• Entwicklung einer Prototyp-Programmierumgebung für Python, einschließlich Programmanalyse- und Management-Tools, die für Anfänger geeignet sind.
• Entwicklung eines Prototyp-Tutorials zur Vermittlung von Programmierung mit Python an Nicht-Programmierer, insbesondere an der High School oder am College, unter Verwendung der oben genannten Programmierumgebung.
• Entwicklung von Beispielsoftware für die oben genannte Zielgruppe; zum Beispiel eine Python-Erweiterung, die die Manipulation einer 3D-Spielumgebung von Drittanbietern ermöglicht.
• Einrichtung und Pflege einer Website und von Mailinglisten, die die oben genannten Software und das Tutorial bewerben und Feedback einholen.
• Zusammenarbeit mit ausgewählten High Schools und Universitäten.
• Durchführung von kleinen Lehr- und Usability-Testing-Maßnahmen.
• Sammeln von Feedback zur oben genannten Software und zum Tutorial von Benutzern, Schülern und Lehrern und Nutzung dieses Feedbacks zur Verbesserung der Software und des Tutorials. Nutzung auch zur Verbesserung der Python-Sprache selbst oder zur Vorschlag einer besseren Sprache.
• Veröffentlichung eines Abschlussberichts, der die Forschung, die gewonnenen Erkenntnisse, die Forschungsergebnisse und die empfohlenen Folgeuntersuchungen dokumentiert.

• Integration von von CNRI entwickelten Tools in Alice.
• Benutzertests der von CNRI entwickelten Tools und des Tutorials.

• Zusammenarbeit mit CNRI zur Entwicklung des von CNRI entwickelten Tutorials zu einem CS-Lehrplan, der für die High School geeignet ist, und separat zu einem CS-Kurs, der für Nicht-CS-Studenten am College geeignet ist.
• Unterrichten von Klassen mit dem entwickelten Lehrplan, um Feedback zu geben.

Zeitplan

Wir stellen uns folgenden Zeitplan für die Bemühungen vor:

• Jahr 1. Anfangsforschung bei CNRI: Entwicklung des anfänglichen Prototyp-Programmierumgebung; Entwurf von Programmanalyse- und Messwerkzeugen; Entwicklung der ersten Version des Tutorials; Aufbau von Kontakten zu anderen Forschern und interessierten Lehrern.

• Jahr 2: Bei CNRI: anfängliche Implementierung von Programmanalyse- und Messwerkzeugen; Sammeln von Feedback aus ersten Erfahrungen mit Software und Tutorial. An der CMU: Beginn der Arbeit an der Integration von von CNRI entwickelten Tools in Alice und Beginn des User-Testings. An der U of C: Beginn der Arbeit an der Lehrplanentwicklung für High School- und College-Studenten.

• Jahr 3: Fortsetzung der obigen Aktivitäten. Zusätzlich bei CNRI: Integration der ersten Programmanalyse- und Messwerkzeuge in die Programmierumgebung; kleiner Rollout der verbesserten Programmierumgebung; Entwicklung anfänglicher Beispielanwendungen; Definition von Bewertungskriterien für den Erfolg. An der CMU: User-Testing der Programmanalyse-Tools. An der U of C: Integration der Nutzung von Programmanalyse-Tools in den Lehrplan.

• Jahr 4: Fortsetzung der obigen Aktivitäten, wobei die meisten davon abgeschlossen werden. Zusätzlich bei CNRI: groß angelegter Rollout der verbesserten Programmierumgebung; Verfeinerung von Beispielanwendungen; Beginn der groß angelegten Sammlung von Endbenutzer-Feedback; Beginn der Arbeit an Änderungen der Python-Sprache. An der CMU: Abschluss des User-Testings, Integration in Alice. An der U of C: Abschluss und Rollout des Lehrplans.

• Jahr 5: Projektabschluss: Bericht über Erfahrungen, Bewertung des Erfolgs, Technologietransfer in die akademische Welt und die Industrie.

Es gibt keine optionalen Aufgaben in diesem Vorschlag.

Referenzen

[ABC]