Archiv

Archive for the ‘Software Entwicklung’ Category

Grundrechenarten Lernprogramm für Sharp Pocket Computer

Mai 27, 2013 2 Kommentare

DSCF7175

Der PC-1260, das erste Modell der winzigen Pocket Computer, die mit einem zweizeiligen Display ausgestattet waren.

Wer im Netz nach nostalgischen Erinnerungen über alte programmierbare Taschenrechner stöbert, findet eine Menge Informationen über Taschenrechner von Hewlett-Packard, Texas Instruments und Casio. Dabei werden immer wieder Geräte wie der HP-25, der HP-65, der TI-58C, der TI-59 oder der FX-602P genannt. Sehr interessant sind auch die immer noch geführten Diskussionen, ob nun UPN oder AOS das bessere System ist.

Ich liebe diese Diskussionen genauso wie die alten Rechenmaschinen, aber manchmal denke ich doch, dass ein Hersteller wie Sharp einfach klüger war, als er 1977 den ersten BASIC-fähigen Pocket Computer, den PC-1201 auf den Markt brachte. Einer der Nachfolger, der PC-1500, war zwar weniger ‚pockettauglich‘, dafür aber mit mehr Speicher, einem grafikfähigen Display und einer Echtzeituhr, ein sehr beliebtes Gerät seiner Zeit.

Nochmals ein paar Jahre später brachte Sharp eine Reihe äußerst bemerkenswerter Pocket Computer auf den Markt: Beginnend mit dem PC-1251, erschien ein BASIC-fähiger Computer, der klein und chic war. Er war kleiner als die meisten Taschenrechner und sah mit seinem metallenen Gehäuse sehr gut aus. Einige Jahre lang entwickelte Sharp diesen Typ kontinuierlich, aber nur marginal, weiter. Lediglich der erste Nachfolger auf den PC-1251, der PC-1260, hatte mit seinem Wechsel von einem einzeiligen auf ein zweizeiliges Display, eine größere Änderung. Der letzte Typ dieser Reihe, der PC-1262, wurde noch bis vor einigen Jahren verkauft.

DSCF7168

Hier kann man schön sehen, wie winzig diese Baureihe war. Links liegt ein aktuelles Smartphone (Galaxy Note), in der Mitte der PC-1260 und rechts der vielleicht bekannteste programmierbare Taschenrechner seiner Zeit, der HP-41C.

Hier findet sich eine sehr gute Übersicht über die Sharp Pocket Computer. Dass dieser Gerätetyp erfolgreich war, kann man sicher auch an den speziell angepassten Gehäusen sehen, die offensichtlich für spezielle  Anwendungen entwickelt worden sind.

Abseits der Hunderten von Funktionen, mit denen die altbackenen Taschenrechner der Konkurrenz um die Gunst des Kunden warben, waren die Pocket Computer eben richtige kleine Computer, in keiner Weise spezialisiert,sondern darauf ausgerichtet, kinderleicht in BASIC programmiert zu werden und so wirklich universell zu sein. Trotz ihrer Winzigkeit – von der Größe her vergleichbar mit heutigen großen Smartphones, also zum Beispiel kleiner als das erste Galaxy Note – besaßen die Pocket Computer eine komplette ‚Qwerty‘-Tastatur! Die Buchstaben-Tasten musste man fast schon mit der Lupe suchen. Der Schlüssel, des in keinem Verhältnis zu ihrer Tastenwinzigkeit stehenden leichten Gebrauchs, lag in dem verhältnismäßig großem Raum um die einzelne Taste. Der reichte aus, dass man beim Tippen keine der Nachbartasten erwischte.

Diese winzigen Computer verstanden eine richtige Computersprache, nämlich BASIC! In Verbindung mit dem sehr guten Display konnte man damit richtig gut und flott programmieren. Das Display war, verglichen mit der Konkurrenz, eine Wucht! Wo die TI’s noch eine rote 7-Segment Anzeige aus stromfressenden LEDs, der HP-41C zwar immerhin schon eine LCD-Anzeige, aber mit merkwürdigen Stellen aus jeweils 14-Segmenten und lediglich der FX-602P schon eine LCD Punktmatrixanzeige besaßen – keine davon mit mehr als 12 Stellen – besaß der PC-1260 eine Punktmatrixanzeige aus zwei Zeilen mit jeweils 24 Stellen! Also 4-mal so viel Platz um Ergebnisse anzuzeigen! Die Anzeige war auch sehr kontrastreich und wesentlich besser abzulesen, als die zweizeilige Anzeige des späteren HP-41C Nachfolgers HP-42S.

DSCF7178

Die Sharp Pocket Computer Reihe war auch sehr flach, wie man hier bei einem Vergleich mit dem HP-41C sieht.

Mag sein, dass die Konkurrenz für schwierige mathematische Probleme besser geeignet war, zum reinen Programmieren waren die winzigen Sharp Pocket Computer ihnen jedenfalls weit voraus. Ja, es macht Spaß mit einem UPN-Stack auszuknobeln, wie man jede Menge Programmschritte spart, aber wenn man ein Problem schnell und sicher lösen will, geht das mit BASIC und dem guten Display wesentlich schneller.

Der weniger nostalgisch veranlagte Leser liest diesen Artikel hier vermutlich schmunzelnd durch und ist froh, dass es heute viel bessere Wege gibt um Software zu entwickeln – an dieser Stelle darf ich vielleicht schnell einmal auf meine beiden Android Apps verweisen: MoveTracker und PiFra – aber es gibt auch heute noch die eine oder andere Anwendung, die auf so einem winzigen alten Pocket Computer richtig Sinn ergibt.

Eine davon möchte ich Euch hier vorstellen. Es ist mein Lernprogramm für die Grundrechenarten. Das Lernprogramm hatte ich ursprünglich für den wesentlich größeren PC-1500 entwickelt und erst viele Jahre später auf dem Kleinen neu programmiert.

Bei so einem Lernprogramm gibt es einige Herausforderungen:

  • Für unterschiedliches Alter und Können sollte es verschiedene Level geben
  • Man darf nicht unendlich viel Zeit für die Aufgaben haben
  • Es sollte irgendwie motivierend sein

Für unterschiedliches Alter und Können sollte es verschiedene Level geben

Der erste Punkt ist mit der schwierigste. Wie gut kann ein Mensch Kopfrechnen? Meine Zielgruppe sind erst einmal meine Töchter. Und die werden ab der 7. Klasse in der Schule mit einem Taschenrechner arbeiten. Aber bis dahin, ist ihre Fähigkeit im Kopf  rechnen zu können bei vielen Aufgaben mit entscheidend, ob sie bei Klassenarbeiten gute Noten schreiben können. Aber schon im Bereich zwischen der ersten Klasse Grundschule und der 7. Klasse auf einem Gymnasium gibt es sehr große Unterschiede im Können. Um diese abzudecken, entschied ich mich für 5 verschieden schwierige Level. Darum muss man bei meinem Programm nach dem Start einen ‚Schwierigkeitsgrad‘ zwischen 1 und 5 eingeben. Daraus muss der Computer dann die Aufgaben erzeugen!

Mein erster Ansatz war den eingegebenen Level ‚l‘ mit der Formel ’10^l‘ in eine obere Grenze für einen Zufallszahlengenerator zu verwenden. Wie sich nach ersten Tests heraus stellte, war das aber ziemlich unsinnig. Es ist ziemlich schwierig, 2 5-stellige Zahlen miteinander zu addieren, von Multiplizieren ganz zu schweigen.

Und vor allem ist der Schwierigkeitsgrad zwischen Addieren/Subtrahieren und Multiplizieren/Dividieren bei Aufgaben mit gleicher Stellenzahl extrem unterschiedlich! Um bei den verschiedenen Grundrechenarten einen etwa gleichen Schwierigkeitsgrad zu haben, muss die Anzahl der Stellen beim Multiplizieren/Dividieren kleiner sein, als beim Addieren/Subtrahieren!

Sehr interessant ist es auch, dass Aufgaben mit Ziffern zwischen 2 und 5 einfacher sind, als Aufgaben mit Ziffern zwischen 6 und 9!

Nachdem ich ein wenig über diese Problematiken nachgedacht hatte, entschied ich mich die Grenzen für die verschiedenen Level und Grundrechenarten in Form von DATA-Zeilen manuell festzulegen.

Man darf nicht unendlich viel Zeit für die Aufgaben haben

Viele der alten Taschenrechner und Pocket Computer sind nicht darauf ausgelegt zeitkritische Probleme zu lösen. Üblicherweise startet man ein BASIC Programm, wird vom Programm dazu aufgefordert ein oder mehrere Werte einzugeben, drückt ‚ENTER‘ und das Programm rechnet eine Zeit lang, ist die Berechnung fertig, gibt das Programm die Ergebnisse auf dem Display aus und beendet sich. Es gibt kaum eine Möglichkeit, während des Programmlaufs irgendwelche Eingaben vorzunehmen. Für einen Trainer ist es aber sehr wichtig, dass er die zur Verfügung stehende Zeit exakt begrenzt, so dass verschiedene Sitzungen mit unterschiedlichen Übenden, vergleichbar sind. Gerade wenn verschiedene Übende mit dem Programm hintereinander üben wollen, muss die Zeit begrenzt sein. Sonst kann es passieren, dass nicht jeder dran kommt. Die begrenzte Zeit sorgt auch für einen gewissen Stress, der so sicher auch bei einer Klassenarbeit vorhanden ist. Man muss sich wirklich konzentrieren, wenn man die Aufgaben in der definierten Zeit lösen will.

Die einzige Möglichkeit die Zeit zu begrenzen, bestand darin, einen Zähler so viele Durchgänge machen zu lassen, bis die gewünschte Zeit verstrichen ist. Aber wie dabei Zahlen eingeben? Zum Glück gibt es im Sharp BASIC eine Funktion namens ‚INKEY$‘, mit der es möglich ist einzelne, auf der Tastatur gedrückte Zeichen abzufragen. Ruft man diese Funktion während eines Schleifendurchgangs des Zählers auf, so bekommt man das gerade gedrückte Zeichen in eine String-Variable übertragen! Man muss dann nur noch die einzelnen Zeichen verknüpfen und in eine Zahl konvertieren. Leider ist dadurch die Zifferneingabe sehr schwierig: Man muss eine Ziffer mindestens solange drücken, dass während des Programmablaufs die INKEY$ Funktion aufgerufen wird und gut darauf acht geben, dass man sie nicht solange drückt, dass INKEY$ gleich zwei Mal vorbei kommt.

Leider kann man das Problem nicht endgültig lösen, darum frage ich neben den Ziffern auch noch die ‚-‚-Taste ab. Drückt man sie, wird das zuletzt eingegebene Zeichen wieder gelöscht. Damit kann man in der einem zur Verfügung stehenden Zeit versuchen, eine falsche Eingabe wieder zu korrigieren. Ach ja, wer das Ergebnis schneller ausgerechnet und eingetippt hat, kann mit der ‚=‘-Taste direkt weiter zur nächsten Aufgabe.

Es sollte irgendwie motivierend sein

Der Pocket Computer kann natürlich nicht das Taschengeld erhöhen oder für erfolgreich gelöste Aufgaben ein Eis spendieren. Aber er kann eine Note berechnen und ausgeben. Die meisten Kinder und natürlich auch Erwachsene können sich unter einer Note etwas vorstellen. Man weiß, dass eine 5 oder eine 6 ziemlich schlecht ist und eine 1 etwas Besonderes ist. Das mag vielleicht keine Riesenmotivation sein, aber meine Kinder möchten schon gerne eine 1 erreichen!

Wir haben im Haus mehrere von den kleinen Dingern und so kann man auch einmal mehrere Kinder gleichzeitig üben lassen. Wenn man zu einem PC-1251, PC-1260, PC-1261 oder einem PC-1262 noch das Zubehör CE-125 hat, kann man ein einmal abgetipptes Programm ausdrucken oder auf einer Kassette abspeichern. Von der Kassette kann man es dann ganz leicht auf einen anderen Pocket-Computer übertragen.

Es macht auch selbst einmal Spaß mit dem Programm zu üben und so ein bisschen Kopfrechentraining kann man immer einmal gebrauchen. Wer ein ähnliches Programm als PC-Anwendung oder App kennt, welches in etwa die gleichen Eigenschaften hat, darf es gerne unten in den Kommentaren angeben.

Und nun viel Spaß beim Abtippen, Modifizieren und Ausprobieren!

100:RANDOM : WAIT 0:AN=12
110:DIM LV(5,4)
120:FOR Y=0 TO 4
130:FOR X=0 TO 5
140:READ LV(X,Y)
150:NEXT X
160:NEXT Y
170:INPUT "Schwierigkeitsgrad (1-5)?",S:S=S-1
180:RI=0

190:FOR I=1 TO AN
200:A= RND 4
210:DA=100+(S+1)*(A+11)

220:IF A<>1 THEN 280
230:E1= RND (LV(1,S)-LV(0,S))+LV(0,S):E2= RND (LV(1,S)-LV(0,S))+LV(0,S)
240:ER=E1+E2
250:AU$= STR$ (E1)+"+"+STR$ (E2)+"=":AL= LEN (AU$)
260:PRINT AU$: GOSUB 700
270:GOTO 480

280:IF A<>2 THEN 350
290:E1= RND (LV(1,S)-LV(0,S))+LV(0,S):E2= RND (LV(1,S)-LV(0,S))+LV(0,S)
300:IF E1<E2 THEN LET H=E1:E1=E2:E2=H
310:ER=E1-E2
320:AU$= STR$ (E1)+"-"+STR$ (E2)+"=":AL= LEN (AU$)
330:PRINT AU$: GOSUB 700
340:GOTO 480

350:IF A<>3 THEN 410
360:E1= RND (LV(3,S)-LV(2,S))+LV(2,S):E2= RND (LV(5,S)-LV(4,S))+LV(4,S)
370:ER=E1*E2
380:AU$= STR$ (E1)+"*"+STR$ (E2)+"=":AL= LEN (AU$)
390:PRINT AU$: GOSUB 700
400:GOTO 480

410:IF A<>4 THEN 480
420:E1= RND (LV(3,S)-LV(2,S))+LV(2,S):E2= RND (LV(5,S)-LV(4,S))+LV(4,S)
430:H=E1:ER=E1:E1=H*E2
440:ER=E1/E2
450:AU$= STR$ (E1)+"/"+STR$ (E2)+"=":AL= LEN (AU$)
460:PRINT AU$: GOSUB 700
470:GOTO 480

480:WAIT 100
500:CURSOR AL+24: PRINT " ";ER;"          "
510:CURSOR AL
520:IF ER<> VAL (ER$) THEN GOTO 560
530:PRINT " RICHTIG"
570:WAIT 0
580:NEXT I

590:WAIT 100
600:PRINT "Richtig sind ";RI;" von ";AN
610:PRINT "Note ";6- INT ((5/AN*RI)+0.5)
620:END

700:ER$=""
710:FOR J=1 TO DA
720:C$= INKEY$
730:IF C$="=" THEN LET J=DA
740:IF C$<>"-" THEN GOTO 780
750:ER$= MID$ (ER$,1,LEN ER$-1)
760:CURSOR AL: PRINT "                " 
770:GOTO 790
780:ER$=ER$+C$
790:USING "#####":CURSOR AL: PRINT VAL ER$
800:NEXT J
810:RETURN

900:DATA 2,9,2,5,2,5
910:DATA 9,50,3,9,3,9
920:DATA 100,300,3,9,11,19
930:DATA 300,1000,11,19,19,50
940:DATA 1000,5000,19,50,19,50

A blast from the past


THE FREE DICTIONARY erklärt die Überschrift mit:

Something that suddenly and strongly makes you remember a previous time.

Vor vielen, vielen Jahren hatte ich in einer Firma die Aufgabe bekommen, ein Shopsystem zu entwickeln. Die Bedingungen waren Windows NT, Oracle und Java. Zu dem Zeitpunkt hatte ich vom Web, außer etwas Erfahrung mit statischen HTML Seiten, absolut keine Ahnung. Lediglich mit Datenbanken und SQL kannte ich mich ganz gut aus und mit Java hatte ich ein paar erste Erfahrungen gesammelt. Also las ich mich in die Thematik ein und stieß relativ schnell auf die Servlet-Technologie von (damals) Sun.

Mit den ersten Versuchen erkannte ich, dass das Kodieren von HTML in ein Java-Servlet schnell zu Problemen führte. Jede kleine HTML-Änderung erforderte das Neukompilieren des Servlets. Es war klar, dass es so nicht gehen konnte. Struts kannte ich damals noch nicht und JSF gab es sowieso noch nicht. Ich bin mir auch nicht sicher, ob es Struts damals schon gegeben hat. Darum erfand ich eine eigene Lösung und nannte sie ‚ShopWizard‘. Es war ein einziges Servlet, welches Templates verarbeiten konnte, in die per Meta-Tags SQL-Statements eingebettet waren.

Anschließend entwickelte ich ein Shopsystem und brachte anderen Mitarbeitern den Umgang mit dem ShopWizard bei. Um mit dem ShopWizard entwickeln zu können, musste man gar nicht programmieren können. Es genügte SQL zu verstehen und schon konnte man, zum Beispiel mit dem Dreamweaver bewaffnet, dynamische Webseiten produzieren. So hatten wir damals eine Ernährungswissenschaftlerin eingestellt, die schon nach kurzer Zeit produktiv mit dem ShopWizard entwickeln konnte.

Eines Tages wollte ich mit dem ShopWizard einmal etwas Eigenes machen und entschloss mich eine eigenschaftsbasierende Kontaktbörse zu entwickeln. In einer knappen Woche abendlicher Arbeit hatte ich es geschafft:

klick2friend war geboren.

Eine Zeit lang durfte ich sie bei uns in der Firma betreiben. Später mietete ich einen Rootserver, den ich vor einigen Jahren allerdings wieder aufgab. Seit kurzem habe ich etwas mehr Zeit und entschloss mich, klick2friend einmal wieder ins Netz zu bringen. Ich musste zwar einiges anpassen, aber nach einem knappen Tag Arbeit hatte ich geschafft.

Leider haben sich damals nur knapp 200 Mitglieder angemeldet. Aber gab es die überhaupt noch? Vielmehr: Waren die damaligen EMail-Adressen noch existent?

Das war eine spannende Frage. Im ShopWizard hatte ich eine interessante Funktion eingebaut, die es erlaubte, per SQL-Abfrage dynamisch generierte EMails zu erzeugen und zu versenden. Dabei konnten nicht nur die Empfänger per SQL bestimmt, sondern auch jede einzelne EMail dynamisch, mit dem ShopWizard selbst, erzeugt werden. Mit dieser Funktion hatte ich schon damals einen Newsletter erzeugt. Und diese Funktion verwendete ich heute, um einmal zu sehen, welche Empfänger-Adressen noch existieren.

Tja, von zuletzt 165 Empfänger-Adressen sind gerade einmal noch 69 geblieben und vermutlich werden in den nächsten Tagen noch weitere heraus fallen. Bin einmal gespannt, ob sich noch einmal jemand von damals anmeldet. Oder gar, ob sich jemand neu registriert?

Wie auch immer, es macht einem ein schönes Gefühl, wenn so eine, etwa 15 Jahre alte, dynamische Web-Anwendung noch einmal zu Leben erwacht und immer noch, auch mit heutiger Technologie, funktioniert.

klick2friend

PiFra, der elektronische Bilderrahmen mit Fernzugriff

Februar 24, 2013 42 Kommentare

Seit ein paar Tagen habe ich eine neue App in Google Play gestellt. Es gibt sie als werbefinanzierte und als Bezahl-Version.  Hier möchte ich sie einmal kurz vorstellen:

Alte Smartphones oder Tablets eignen sich hervorragend dafür, als elektronischer Bilderrahmen eingesetzt zu werden. Da viele Geräte auch über WLAN verfügen, kann man sich auch vorstellen, sie bei Oma oder Opa, oder sonst wem, den man gerne mag, aufzustellen und sie automatisch mit neuen Bildern zu bestücken. Eine Zeit lang suchte ich darum nach einer passenden App für eine solche Verwendung, fand jedoch keine. Darum habe ich mir nun PiFra programmiert, welches genau die Funktionen hat, die ich benötige:

  • Zeigt alle Bilder eines angegebenen Verzeichnisses, inklusive aller Unterverzeichnisse, an, auch wenn dies viele tausend sind.
  • Gestattet individuelle Einschaltzeiten für jeden Wochentag. Das ist sehr wichtig! Denn normalerweise will niemand einen elektronischen Bilderrahmen haben, der auch nachts wenn man schläft, vor sich hin glüht.
  • Lässt sich über EMails automatisch mit neuen Bildern bestücken!

Gerade letzteres ist sehr interessant, da es im Gegensatz zu anderen Lösungen keinem Zwischenglied bedarf. Andere Lösungen setzen zum Beispiel auf einen Server, auf dem die Bilder über einen Browser verwaltet werden und/oder auf dem auch EMails zwischengespeichert werden. Dies ist bei der PiFra-Lösung beides nicht notwendig!

PiFra kann man einfach einen EMail-Account angeben. Alle an diesen Account gesendeten EMails, die ein oder mehrere Bild/Bilder und den Betreff ‚pifra’ im Anhang enthalten, kann PiFra empfangen und anzeigen. Das macht es dann sogar der ganzen Familie möglich, Oma oder Opa von Zeit zu Zeit ein Bild per EMail zu senden, welche anschließend vollautomatisch von PiFra angezeigt werden. Oma oder Opa werden sich freuen, wenn auf ihrem ‚elektronischen Bilderrahmen‘ immer einmal wieder neue Bilder erscheinen und vielleicht sogar anrufen, um weitere Informationen zum Bild zu bekommen.

Durch die EMail-Technik kann jeder/jede mit einem Smartphone direkt ein Photo machen und per EMail an PiFra senden!

Mit dem Netbook unter Ubuntu in Delphi programmieren?

Mai 11, 2012 1 Kommentar

Ganz so ist es nicht. Aber es gibt ja doch einige Entwickler, die ihr Handwerk in grauer Vorzeit mit Turbo-Pascal gelernt haben. Wer dann später den Aufstieg in die Windows Welt geschafft hat, hat möglicherweise seine Turbo-Pascal Kenntnisse unter Delphi weiter gepflegt. Delphi war – und ist möglicherweise immer noch – eines der besten Entwicklungssysteme für Windows.

In der Vergangenheit habe ich temporär mit Delphi 1.0, 2.0 und 3.0 gearbeitet. Spätere Versionen habe ich aber nur noch flüchtig ausprobiert. Zu Zeiten von Delphi 1.0 war es unglaublich aufwendig, für Windows eine fensterbasierende Anwendung zu entwickeln. Delphi brachte aus diesem Grund einen integrierten GUI-Builder mit, mit dem man in wenigen Minuten eine komplette native Anwendung für Windows entwickeln konnte. Diese Eigenschaft machte Delphi sehr populär. Übrigens ist der integrierte GUI-Builder auch heute noch eines der wesentlichen Argumente für die Netbeans IDE, die andere große Entwicklungsumgebung neben der Eclipse IDE.

Doch was soll dieser kurze Ausflug in die Vergangenheit der Software-Entwicklung?

Es gibt seit langer Zeit eine Art Nachbau von Delphi, der sogar unter Ubuntu läuft! Im Rahmen meiner Experimente mit Ubuntu habe ich diesen kurz ausprobiert. Er lässt sich über ‘Ubuntu Software-Center -> Entwicklungswerkzeuge -> Entwicklungsumgebungen’ schnell finden und installieren. Ich hab’s gemacht und innerhalb weniger Minuten ein kleines Fenster mit einer Schaltfläche und einem Eingabefeld designt/programmiert!

Wer sich dafür interessiert, der sei hiermit auf Lazarus verwiesen. 🙂

Achtung: Bei einem neuerlichen Versuch hat es nicht gleich geklappt. Daraufhin habe ich mit folgenden beiden Kommandos im Terminal-Fenster den Quellcode und die Units neu installiert:

sudo apt-get install fpc-source
sudo apt-get install fp-units-i386

Ich kann mich nicht daran erinnern, ob ich jetzt anschließend über ‚Einstellungen -> IDE Einstellungen‘ die Pfade neu angepasst habe oder nicht. Jedenfalls habe ich es damit zum Laufen gebracht.

Mit dem Netbook unter Ubuntu für Android entwickeln

Mai 11, 2012 2 Kommentare

Ob es wirklich Sinn macht, ist fraglich, da so ein Netbook-Display ja doch nur eine vergleichsweise geringe Auflösung hat und dadurch die vielen Fenster von Eclipse nicht viel Platz für ihren Inhalt haben. Aber ich wollte einmal grundsätzlich wissen, ob es funktionieren könnte und eventuell kann man ja auch einen Monitor anschließen.

Vielleicht hilft es auch dem einen oder anderen Netbook-Besitzer den Einstieg in die Java Programmierung zu finden.

Andererseits wäre es eine Möglichkeit, abseits von zu Hause, mal eben schnell einen Fehler in GPSSend zu korrigieren!

Um es für mich noch interessanter zu gestalten, habe ich es unter Ubuntu ausprobiert. Ich wollte einfach einmal sehen, wie schwierig es ist, einen Netbook unter Ubuntu zum Software entwickeln einzusetzen. Um es vorweg zu nehmen, es ist nicht schwierig, sondern sogar relativ leicht!

Mit Hilfe von UNetbootin habe ich das neueste Ubuntu (12.04 LTS) auf einen USB Stick kopiert und es anschließend auf einem Acer D270 installiert. Die restliche Installation bzw. Einrichtung kann man anschließend über WLAN machen.

Eclipse installieren

Man kann wohl auch mit einem simplen Editor für Android entwickeln, das habe ich aber nie ausprobiert. Die meisten Empfehlungen im Netz schlagen Eclipse als Entwicklungsumgebung für Android vor. Auch ich habe bisher für die Entwicklung von GPSSend Eclipse – allerdings unter Windows XP und Windows 7 – eingesetzt.

Die Installation von Eclipse unter Ubuntu ist sehr einfach. Am linken Rand befindet sich ein Icon mit der Bezeichnung ‚Ubuntu Software-Center‘. Über den Weg ‚Ubuntu Software-Center -> Entwicklungswerkzeuge -> Entwicklungsumgebungen -> Eclipse -> installieren‘ startet man die Installation.

Aktuell hat man anschließend ‚Eclipse Indigo‘ auf seinem Netbook installiert.

ADT Plugin und SDK installieren

Nur mit Eclipse kann man nicht für Android entwickeln, es werden noch einige Zusätze benötigt.

Man kann den Anweisungen der ‚android developers‚ folgen. Die führen auch zum Ziel. Aber es gibt einen einfacheren Weg, der im Nachfolgenden beschrieben wird. Dazu muss in Eclipse eine Software-Quelle eingerichtet werden, von der aus dann die Installation der zusätzlichen Komponenten erfolgen kann.

Zuerst ruft man über ‚Help -> Install New Software…‘ das in Eclipse gebräuchliche Fenster für die Installation von Plugins aus. Dort wählt man ‚Add‘, es erscheint ein weiteres Fenster, in dem man einen Namen für eine Software-Quelle, zum Beispiel ‚ADT Plugin‘, und die URL der Quelle angeben muss. Die Quelle ist:

https://dl-ssl.google.com/android/eclipse/

Nachdem man die neu eingerichtete Quelle ausgewählt hat, um darüber nach passender Software zu suchen, kommt das erste echte Netbook-spezifische Problem: Das Fenster ist zu klein, die Liste, die eigentlich die zur Auswahl stehenden Einträge anzeigen sollte, ist so zusammengepresst, dass man keinen einzigen Eintrag sehen kann!

Darum klickt man einfach auf ‚Select All‘, wartet einen Moment und sollte dann rechts neben der Liste ‚4 Items selected‘ sehen. Mit einem Klick auf ‚Next‘ geht es zum Akzeptieren der Lizenzen. Hier kann man einfach ‚I accept the terms of the license agreements‘ anklicken und dann noch einmal auf ‚Finish‘. Anschließend wird das Plugin downgeloadet und man wird zu einem Restart von Eclipse aufgefordert.

Den sollte man auch durchführen, da man dann automatisch dazu aufgefordert wird, die restlichen Pakete, wie das SDK und die Android Version 2.1, zu installieren. Die Auswahl von Android 2.1 muss man durch Anklicken bestätigen. Dann geht es noch einmal zum Lizenzen akzeptieren.

Man wird zu einem Restart aufgefordert. Nach dem Restart hat man die Möglichkeit ein SDK downzuloaden und zu installieren, sowie Android 2.1. Das sollte man auch tun.

Daraufhin erscheint ein Fenster, in dem man die Möglichkeit hat, einzelne Pakete auszuwählen. Hier klickt man am besten ‚Accept All‘ an und wählt anschließend ‚Install‘.

Jetzt dauert es einige Zeit.

Anschließend ist Eclipse fertig präpariert für erste Versuche in der Android-Entwicklung. Ich habe für einen ersten Test mein GPSSend-Projekt von Windows 7 mit Hilfe eines USB Sticks in den Workspace von Eclipse in mein Home-Verzeichnis kopiert. Nachdem ich noch die Bibliotheken neu angegeben hatte, konnte ich GPSSend über ‚Clean‘ komplett neu erzeugen.

Der hier beschriebene Weg erfordert außer WLAN, dem Wissen um die Android Software-Quelle und etwas Zeit, keinerlei weitere Zutaten, um unter Ubuntu eine Entwicklungsumgebung für Android aufzusetzen! Sicherlich ist ein Desktop mit 1024 mal 600 Pixeln etwas wenig für Eclipse, aber grundsätzlich funktioniert es. Man beachte dabei, dass jedes Fenster in Eclipse durch einen Doppelklick auf die Titelzeile maximiert werden kann!

Heutzutage scheint es erstaunlich, dass man auf so einem kleinen Gerät richtig entwickeln kann, aber wer vor ca. 10 Jahren schon mit Eclipse entwickelt hat, der weiß, dass ein Dual-Core Mikroprozessor und 2 GByte RAM schon eine ganze Menge ‚Power‘ sind! 🙂

USB für das eigene Smartphone aktivieren

Was jetzt noch fehlt, ist das Testen der Anwendung direkt auf dem Smartphone. Dazu muss man in Eclipse leider erst ein paar Kommandzeilenaufrufe durchführen. Welche das sind, wird bei ‚android developers‘ genau beschrieben:

USB für Smartphones aktivieren

Das wichtigste daraus:

Ein Terminal-Fenster öffnen und darin:

sudo gedit /etc/udev/rules.d/51-android.rules

angeben. Folgende Zeile eintippen:

SUBSYSTEM=="usb", ATTR{idVendor}=="22b8", MODE="0666", GROUP="plugdev"

und speichern (Die Vendor-ID ist passend für mein Motorola – für andere Hersteller muß eine andere Vendor-ID angegeben werden – siehe hier). Zum Abschluß im Terminal-Fenster noch:

sudo chmod a+r /etc/udev/rules.d/51-android.rules

eintippen.

Anschließend kann man über Eclipse die Anwendung direkt auf dem Smartphone ausführen und testen. Und so, nur mit dem Netbook und dem Smartphone ausgerüstet, auch unterwegs mal eben schnell ein paar Änderungen an der eigenen App vornehmen! Und das sogar unter Linux!

Delphi 3.0 unter Windows 7


Im Sommer 2011 kaufte ich mir ein Notebook. Um nicht zu viel Zeit mit der Installation eines neuen Betriebssystems zu verbrauchen, kaufe ich meine Rechner meist mit vorinstalliertem Betriebssystem. Darum kam ich diesmal nicht mehr um Windows 7 herum.

Vor vielen, vielen Jahren entwickelte ich einige Zeit lang mit Borland Delphi, eine der besten Entwicklungsumgebungen, die es für Windows gab und immer noch gibt.

Vor ein paar Tagen fragte mein Vater folgendes:

„Ich hätte gerne ein HTML-Script, welches genau diesen Befehl ausführt. Ich habe es mit „href….“  und mit src…..“ probiert, aber das funktioniert nicht. Ich möchte dieses Script local durch den Taskmanager starten, da cronjob.de kostenpflichtig ist.“

Zuerst probierte ich es mit

http:www.beispiel.de">

Dies funktionierte zwar, führte aber zu einem zusätzlichen Popup, welches man erst noch weg klicken musste. Da probierte ich es mit


Das gleiche Ergebnis. Da kam mir der Gedanke, einfach selbst schnell ein kleines Programm zu entwickeln, welches den HTTP-Request durchführt, die Seite entgegen nimmt und einfach nicht weiter auswertet.  Bei der Überlegung mit welchem Entwicklungssystem ich dass jetzt schnell machen könnte, viel mir auf, dass ich auf meinem Notebook noch keines installiert habe, mit dem man ‚mal eben schnell eine kleine EXE-Datei kompilieren kann…

Ich habe zwar Netbeans und Eclipse installiert und kann auch Apps für Android entwickeln, aber die guten alten EXE-Programme? Das ging noch nicht. Aber wozu habe ich noch irgendwo eine Delphi CD liegen? Also aus dem Regal heraus gesucht, in das DVD-Laufwerk eingelegt und schnell installiert. Es handelte sich um die Version 3.0 – leider lies sie sich nicht installieren. Das Installationsprogramm brach mit einer Fehlermeldung, aufgrund einem Kompatibilitätsproblem mit dem 64 Bit Windows, ab.

Meine bisherigen Erfahrungen bei der Umstellung verschiedener Software auf mein ‚Windows 7 Home Premium‘ zeigte aber, dass man mit dem einen oder anderen Trick das meiste doch zum Laufen bekommt. Also habe ich erst einmal ein wenig im Internet recherchiert und bin dabei auf diese Seite gestoßen, auf der der Beitrag von ‚lewis‘ den Weg zur funktionierenden Installation schon einmal sehr gut vorgibt. Er beschreibt es allerdings für Delphi 5.0 und es kann sein, dass einige der Probleme, die ich nach Anwendung seiner Tipps immer noch hatte, darin ihre Ursache haben.

Der Kern seiner Beschreibung beruht darin, dass man versucht eine funktionierende Installation auf das Zielsystem (Windows 7) zu übertragen!

Daraus das wichtigste:

1. Von einer funktionierende Delphi 3.0 Installation folgende Dateien sichern:

\windows\system32\*.dpl
kompletter Verzeichniszweig \Program Files\Borland
kompletter Verzeichniszweig \Program Files\Common Files\Borland Shared

2. Von einer funktionierende Delphi 3.0 Installation folgende Registry-Zweige sichern:

HKEY_CURRENT_USER\Software\Borland
HKEY_LOCAL_MACHINE\SOFTWARE\Borland

Die Dateien hebt man sich am besten an einem sicheren Platz für die Zukunft auf.

3. Nun kann man das Delphi 3.0 System auf den Notebook kopieren, sollte aber darauf achten, dass dort Programme unter ‚Programme (x86)‘ gespeichert werden. Darum müssen die vorher über den Registry-Editor exportierten ‚REG‘-Dateien angepasst werden. Ich habe dazu Notepad++ verwendet. Mit dessen Hilfe in beiden REG-Dateien ‚\\Programme‘ durch ‚\\Programme (x86)‘ austauschen. Anschließend kann man sie im Windows-Explorer doppelklicken und damit in die Registry des Zielsystems importieren.

4. Im Zielsystem die Umgebungsvariable ‚PATH‘ um den Eintrag ‚C:\Program Files (x86)\Borland\Delphi 3\Bin‘ erweitern.

Nachdem ich bis hierher gekommen bin, lies sich Delphi immerhin schon einmal – wenn auch unter Stottern – starten. Das Stottern kam daher, dass es die unter ‚Projektoptionen/Packages‘ eingetragenen ‚Entwurfszeit-Packages‘ nicht gefunden hat. Es war auch kein Haken zu sehen. Wenn ich versucht habe den Haken zu setzen, kam die gleiche Fehlermeldung wie beim Start. Eigentlich hätten dies ja die Registry-Änderungen lösen sollen. Hat aber offensichtlich nicht geklappt. Klickt man dort die einzelnen Komponenten an, so wird der Pfad angezeigt und er schien zu stimmen. Lösen konnte ich dieses Problem damit, dass ich jedes Package noch einmal über die Schaltfläche ‚Hinzufügen‘ ausgewählt habe!

Anschließend lies sich Delphi ohne Probleme starten.

Beim ersten Versuch ein kleines Projekt zu kompilieren, erschien aber folgende Fehlermeldung:

‚Fataler Fehler: C:\Work\Delphi Test\Project1.dpr(1): Datei nicht gefunden: ‚System.pas.‘

Eine Recherche im Internet ergab leider – außer der Erkenntnis, dass auch andere dieses Problem haben – nichts. Also habe ich selbst noch ein bisschen nachgedacht und experimentiert und bin auf folgende einfache Lösung gestoßen: Man muss für jedes alte und neue Projekt unter ‚Projektoptionen/Verzeichnisse/Bedingungen‘ im Feld ‚Suchpfad.‘ den Pfad auf das ‚Bin‘-Verzeichnis von Delphi eingeben, dann kann klappt alles. Also zum Beispiel:

C:\Program Files (x86)\Borland\Delphi 3\Bin

Dies muss man jetzt allerdings für jedes Projekt machen, was vorher unter XP nicht der Fall war. Dieser Umstand führte zu weiteren Untersuchungen und mittlerweile denke ich, die Wurzel des Problems gefunden zu haben: Man darf beim Suchen und Ersetzen nicht ‚Programme (x86)“ verwenden, sondern stattdessen das englische ‚Program Files (x86)‘ – dann klappt es gleich!

Noch ein paar Tipps:

Ich habe früher oft mit der Borland Datenbank ‚Interbase‘ gearbeitet. Diese wurde mittlerweile als Open Source freigegeben und wiederum davon gibt es den Ableger ‚Firebird‚. Den kann man verwenden um weiterhin seine Datenbanken zu verwenden. Downgeloadet habe ich diese Variante. Nach der Installation findet sich im ‚bin‘-Verzeichnis von Firebird eine DLL ‚fbclient.dll‘, die für den Zugriff auf Firebird durch verschiedene Bibliotheken, wie zum Beispiel ‚SQLDirect‚, notwendig ist.

Diese Datei muss man ins Verzeichnis ‚C:\Windows\SysWOW64‘ kopieren, damit der Zugriff weiterhin funktioniert!