Kompetenzorientierter Informatikunterricht in der Sekundarstufe I unter Verwendung der visuellen Programmiersprache Puck

In dieser Arbeit wurde die aktuelle Diskussion um Bildungsstandards sowie die spezifische Situation in der Informatik dargestellt. Weiterhin wurde auf Kompetenzen, Kompetenzmodelle und zugehörige Aufgaben eingegangen. Ausgehend von diesen Analysen wurde auf Grundlage der von der GI empfohlenen „Grundsätze und Standards für Informatik in der Schule“ ein Kompetenzmodell für den Inhaltsbereich „Algorithmen“ der 8. bis 10. Jahrgangsstufe zusammen mit Aufgaben zum Verdeutlichen, Erwerben und Überprüfen der Kompetenzen entwickelt. Die gewonnenen Erfahrungen bei der Entwicklung des Kompetenzmodells und der Aufgaben wurden jeweils zusammengefasst. Das Erwerben von Kompetenzen zum Inhaltsbereich „Algorithmen“ ist häufig mit dem Einsatz einer konkreten Programmiersprache verbunden. Die vom Autor erstellte visuelle Programmiersprache Puck wurde im Rahmen dieser Arbeit weiterentwickelt und von verschiedenen anderen visuellen Werkzeugen abgegrenzt. Weiterhin wurden Gründe dargestellt, die für den Einsatz solcher visueller Werkzeuge bei der Einführung in die Programmierung sprechen. In einer Voruntersuchung an sechs Thüringer Schulen wurden erste Erfahrungen zu kompetenzorientiertem Informatikunterricht unter Verwendung der entwickelten Materialien und der visuellen Programmiersprache Puck zusammengetragen. Auf Grundlage dieser Ergebnisse wurden in der Hauptuntersuchung 84 Lehrerinnen und Lehrern im deutschsprachigen Raum das weiterentwickelte Kompetenzmodell, die zugehörigen Aufgaben und Puck zur Verfügung gestellt. Die Befragung von 40 Lehrpersonen, am Ende der Hauptuntersuchung ergab, dass es einem Großteil der Lehrkräfte möglich war, anhand der bereitgestellten Materialien kompetenzorientierten Informatikunterricht zu strukturieren, vorzubereiten, durchzuführen und auszuwerten. Es zeigte sich außerdem, dass die visuelle Programmiersprache Puck größtenteils als geeignet für eine Einführung in die Programmierung in den Jahrgangsstufen 8 bis 10 eingeschätzt wurde

Flexible und plattformunabhängige Entwicklung mikrocontrollerbasierter mechatronischer Systeme für Nutzer ohne Vorwissen

Der steigende Bedarf an mikrocontrollerbasierten mechatronischen Systemen ist heute nicht mehr zu übersehen. Zur Deckung des Bedarfs werden gewöhnlich modellbasierte Methoden eingesetzt, welche die Arbeit der Experten beschleunigen. Diese Methoden sind aber selbst für technikbegeisterte Laien oft nicht einsetzbar, da sie ein fundiertes Vorwissen voraussetzen. An dieser Stelle setzt die vorliegende Arbeit an. Sie stellt verschiedene Konzepte vor, mit welchen es möglich ist, die elektronische Hardware und die Software für mikrocontrollerbasierte mechatronische Systeme zu entwickeln, ohne dass hierfür Vorwissen auf den Gebieten der Elektronikentwicklung oder der Informatik benötigt wird. Eine solche Vereinfachung geschah bisher gewöhnlich nur durch die Kapselung hardwarenaher Funktionen in abstrakten Modulen. In der vorliegenden Arbeit wird jedoch ein anderer Weg gewählt. Die Nutzer sollen während der Nutzung ein Grundverständnis für die Funktionsweise mechatronischer Systeme erlangen.In this thesis new concepts for designing development systems for mechatronic systems are introduced. The concepts allow flexible and simple usage, even if the users don’t have prior expert knowledge. For this purpose, approaches are presented, which allow a transparent illustration of the mode of operation of sensors, actuators and used platforms, allowing users to understand related technical topics.In the first part of the thesis, basic knowledge and the state of the art are presented. After this, the concepts of the microsystems development systems “EasyKit” and “EasyKit macht Schule” are described. In these systems microcontrollers are used as platform, because they already contain a high functional integration. Because of this, novice users prefer to use them as platform of choice. The electronic circuits, including the microcontroller, are provided in shape modular hardware blocks. They are programmed graphically with modular software blocks. The approach of programming introduced, uses a combination of the advantages of sequential function charts and synchronous data flow charts which increases the flexibility. Tests showed that even users without prior technical knowledge were able to program the microcontroller with these languages.The EasyKit concept was advanced, to offer increased flexibility and simplicity during programming. Besides, there was the goal to give users without expert knowledge the capability of developing electronics on the circuitry level, which is far more flexible than developing on the modular level. For this purpose, requirements are analyzed and new approaches are presented in the thesis. The most important approach, to make the soft-ware development more flexible, is the introduction of a new additional programming level, which supports graphical and textual programming methods at the same time. For assisting the user during the hardware development on the circuitry level, approaches are presented, which allow modeling most sensors and actuators, by abstracting them to their types of interfaces. Through this, the user can be supported when developing driver circuits to be used between the sensors, actuators and the microcontroller. Besides, this approach allows a comprehensible visualization of the signal behavior and the signal transformation at the interface of the microcontroller. Further approaches to increase the usability during the development phase are also presented in the thesis.The most promising approaches were implemented to a development environment and tested with members of the target audience

Kombination dynamischer und formaler Methoden zur Verifikation objektorientierter Software

Der Anteil von Software in industriellen Gütern und Dienstleistungen steigt stetig und deren Korrektheit ist eine deren wichtigsten Eigenschaften. Häufig werden für die Entwicklung objektorientierte Programmiersprachen eingesetzt. Die Korrektheit objektorientierter Software kann mit Hilfe dynamischer Testverfahren oder mit Hilfe formaler Methoden verifiziert werden. Dynamische Testverfahren können leicht auf jede Software angewandt werden, garantieren jedoch keine Fehlerfreiheit. Methoden der formalen Verifikation können hingegen dafür genutzt werden, Fehlerfreiheit zu garantieren. Jedoch ist ihre Anwendung wesentlich komplexer. In dieser Arbeit wird ein neues Verfahren zu Kombination modularer, formaler Verifikationsmethoden und dynamischer Testverfahren vorgestellt. Das Ziel der vorgestellten Methodik ist es möglichst große Anteile der Software automatisiert, modular und formal zu verifizieren. Dadurch können zeitintensive, dynamische Testfälle eingespart und die Sicherheit der Software erhöht werden. Die Korrektheit von Programmabschnitten, die nicht formal verifiziert werden konnten, wird mit dynamischen Testfällen und Robustheitstests überprüft. Die Robustheitstests simulieren Fehler bezüglich aller nicht formal verifizierten Programmeigenschaften. Mit Hilfe dieser Tests wird das Verhalten der formal verifizierten Programmabschnitte im Fehlerfall analysiert. Ein sicherer Umgang mit Fehlern verhindert, dass Fehler unbemerkt durch das Gesamtsystem propagiert werden können. Stattdessen werden Fehler durch das Programm korrigiert oder die Programmausführung mit einem definierten Prozess unterbrochen. Die Robustheitstests helfen dem Entwickler, die notwendige Fehlerbehandlung zu identifizieren, zu entwickeln und final zu testen. Die auf diesem Weg entstandene Fehlerbehandlung erhöht auch die Robustheit des Gesamtsystems gegenüber potentiell nicht entdeckter Fehler.Erste PDF enthält Abbildungen in scharz-weiß; zweite PDF enthält farbige Abbildungen

Debugging im Informatikunterricht

Debugging ist ein Schlüsselproblem des Informatikunterrichts: Programmierfehler zu finden und zu beheben stellt für Schülerinnen und Schüler ein erhebliches Hindernis beim Programmierenlernen dar und ist eine große Quelle für Frustration. Gleichzeitig stehen aber auch die Lehrkräfte vor der enormen Herausforderung, allen Lernenden gleichzeitig gerecht zu werden. Nichtsdestotrotz fehlt es bisher an informatikdidaktischer Forschung, die sich diesem gravierenden schulpraktischen Problem annimmt. In dieser Arbeit wird gemäß dem Forschungsformat der didaktischen Rekonstruktion der Prozess Debugging aus informatikdidaktischer Sicht aufgearbeitet. Dazu werden zunächst im Zuge der fachlichen Klärung vier Fähigkeiten identifiziert, die Schülerinnen und Schüler für selbstständiges Debugging benötigen: Die Anwendung eines systematischen Debuggingvorgehens, die Anwendung von Debuggingstrategien, die Verwendung von Heuristiken und Mustern für typische Fehler sowie von Werkzeugen. Das daraus resultierende Modell der Debuggingfähigkeiten für Novizen stellt damit die inhaltliche Basis für die Vermittlung von Debugging dar. Weiterhin wird die Perspektive der Lehrkräfte untersucht und analysiert, mit welchen Herausforderungen diese beim Debuggen im Unterricht konfrontiert sind und wie sie mit diesen umgehen. Die Lehrkräfte berichten dabei von großen Schwierigkeiten aufgrund mangelnder Selbstständigkeit der Schülerinnen und Schüler bei der Fehlerbehebung. Außerdem unterrichten sie Debugging kaum explizit, da es ihnen an Zeit, Konzepten und Materialien fehlt. Aus ihren Erfahrungen können weiterhin Gestaltungshinweise abgeleitet werden, wie etwa, dass Debugging nicht "auf Vorrat", sondern bei Bedarf unterrichtet und dabei die Selbstständigkeit der Lernenden auch aktiv eingefordert werden sollte. Darüber hinaus werden gesellschaftliche Ansprüche des Debugging untersucht und drei mögliche Beiträge zur Allgemeinbildung identifiziert: Zur Erklärung des Phänomens "fehlerhafte Software" aus der Lebenswelt, bezüglich des Lernens aus Fehlern sowie als Herangehensweise des Computational Thinking für Troubleshooting im Alltag. Daneben werden hinsichtlich der Perspektive der Lernenden Debugging-Lernvoraussetzungen von Schülerinnen und Schülern anhand ihres Vorgehens beim Troubleshooten erhoben, die deren Debuggingvorgehen beeinflussen. So wenden die Lernenden zwar ein systematisches Vorgehen für das Troubleshooten an und beziehen bisherige Erfahrungen und Muster für typische Fehler mit in diesen Prozess ein, haben aber insbesondere Probleme mit dem Aufstellen von (Alternativ-)Hypothesen oder dem Rückgängigmachen von erfolglosen Änderungen. Weiterhin haben sie Schwierigkeiten mit der Anwendung von Strategien wie dem Testen oder einer topographischen Suche, die entsprechend im Informatikunterricht adressiert werden müssen. Auf dieser Basis werden zehn Gestaltungskriterien für Konzepte und Materialien für das Debugging im Unterricht entwickelt sowie ein konkretes integratives Unterrichtskonzept für den Informatikunterricht entworfen. Die Wirksamkeit der expliziten Vermittlung von Debugging wird anhand des Unterrichtskonzepts empirisch validiert: Die Ergebnisse zeigen dabei die Bedeutung eines systematischen Vorgehens als Grundlage für erfolgreiches Debugging für Novizen auf und verdichten empirisch die These, dass Debugging explizit vermittelt werden sollte. Abschließend wird die Praxiswirksamkeit der Ergebnisse die Gestaltung einer Fortbildung untersucht und bezüglich des Transfers in die Unterrichtspraxis evaluiert. Dabei zeigt sich, dass die professionelle Kompetenz der Lehrkräfte sowie der Stellenwert des Themas Debugging für ihren Unterricht gestiegen ist. Außerdem versuchen sie, eine positive Fehlerkultur im Unterricht zu etablieren, und adaptieren und erweitern dazu die Fortbildungsinhalte. Zusammenfassend legt diese Arbeit damit die theoretische Grundlage für die Vermittlung von Debugging im Unterricht, indem relevante Debuggingfähigkeiten, unterrichtspraktische Anforderungen und Lernvoraussetzungen identifiziert werden. Darüber hinaus geben die Gestaltungskriterien sowie das evaluierte Unterrichtskonzept eine praxiswirksame Antwort auf die Frage, wie Debugging im Unterricht vermittelt werden kann. Neben diesen inhaltlichen Beiträgen werden im Rahmen dieser Arbeit zudem zwei methodische Beiträge geleistet. So wird einerseits ein Instrument zur Messung von Debuggingleistung und andererseits ein innovativer methodischer Ansatz zur Untersuchung von Troubleshooting-Vorgehensweisen entwickelt

Engineering wissensbasierter Navigation und Steuerung autonom-mobiler Systeme

Die autonome Steuerung mobiler, technischer Systeme in nicht exakt vorherbestimmbaren Situationen erfordert Methoden der autonomen Entscheidungsfindung, um ein planvolles, zielgerichtetes Agieren und Reagieren unter Echtzeitbedingungen realisieren zu können. Während mittels mathematischer Formeln Basisverhalten, wie beispielsweise in einer Geradeausbewegung, einer Drehung, bei einem Abbremsen, und in Gefahrenmomenten schnelle Reaktionen, berechnet werden, benötigt man auf der anderen Seite ein Regelsystem, um darüber hinaus "intelligentes", d.h. situationsangepaßtes Verhalten zu produzieren und gleichzeitig im Hinblick auf ein Missionsziel planvoll agieren zu können. Derartige Regelsysteme müssen sich auf einer abstrakten Ebene formulieren lassen, sollen sie vom Menschen problemlos entwickelbar, leicht modifizierbarund gut verifizierbar bleiben. Eine aufgrund ihres Konzeptes geeignete Programmierwelt ist die Logikprogrammierung. Ziel der Logikprogrammierung ist es weniger, Arbeitsabläufe zu beschreiben, als vielmehr Wissen in Form von Fakten zu spezifizieren und mit Hilfe von Regeln Schlußfolgerungen aus diesen Fakten ziehen zu können. Die klassische Logikprogrammierung ist jedoch aufgrund ihres Auswertungsmechanismus der SLD-Resolution (linear resolution with selected function for definite clauses) zu langsam für die Anwendung bei Echtzeitsystemen. Auch parallele Sprachformen, die ebenfalls mit SLD-Resolution arbeiten, erreichen beim Einsatz auf (von Neumann-) Mehrprozessorsystemen bislang nicht die notwendige Effizienz. Das Anwendungsgebiet der deduktiven Datenbanken hat im Vergleich dazu durch Bottom-Up Techniken einen anderen Auswertungsansatz mit deutlich höherer Effizienz geliefert. Viele dort auftretenden Probleme können jedoch nur durch die Integration anforderungsgetriebener Abarbeitung gelöst werden. Auf der anderen Seite stellen Datenflußrechnerarchitekturen aufgrund der automatisierten Ausbeutung feinkörniger Parallelität einen hervorragenden Ansatz der Parallelverarbeitung dar. Bei Datenflußrechnerarchitekturen handelt es sich um (Mehrprozessor-) Systeme, deren datengetriebener Abarbeitungsmechanismus sich grundlegend vom weit verbreiteten kontrollflußgesteuerten von Neumann-Prinzip unterscheidet.Überlegungen zur Struktur von Steuerungssystemen werden ergeben, daß es mittels Ansätzen aus dem Gebiet der deduktiven Datenbanken möglich ist, ein für diese Aufgabenstellung neuartiges, ausschließlich datengetriebenes Auswertungsmodell zu generieren. Dabei vermeidet es Probleme, die bei Bottom-Up Verfahren auftreten können, wie z.B. das Auftreten unendlicher Wertemengen und die späte Einschränkung auf relevante Werte, ohne gleichzeitig die Stratifizierung von Programmen zu gefährden. Ergebnis der Arbeit ist eine anwendungsbezogene, problemorientierte Entwicklungsumgebung, die einerseits die Entwicklung und Verifikation der Spezifikation mit existierenden Werkzeugen erlaubt und andererseits die effiziente, parallele Ausführung auf geeigneten Rechensystemen ermöglicht. Zusätzlich wird die Voraussetzung geschaffen, verschiedene weitere, für die Steuerung autonomer Systeme unverzichtbare Komponenten in das Abarbeitungsmodell zu integrieren. Simulationsergebnisse werden belegen, daß das vorgestellte Berechnungsmodell bezüglich realer Anwendungsbeispiele bereits in einer Monoprozessorversion Echtzeitbedingungen genügt. Damit ist die Voraussetzung für die Ausführung zukünftiger, weitaus komplexerer Steuerungsprobleme, ggf. auf Mehrprozessorsystemen, in Echtzeit geschaffen