Cookies op Tweakers

Tweakers maakt gebruik van cookies, onder andere om de website te analyseren, het gebruiksgemak te vergroten en advertenties te tonen. Door gebruik te maken van deze website, of door op 'Ga verder' te klikken, geef je toestemming voor het gebruik van cookies. Wil je meer informatie over cookies en hoe ze worden gebruikt, bekijk dan ons cookiebeleid.

Meer informatie

Door , , 191 reacties

De programmeertaal BASIC bestaat donderdag vijftig jaar. Op 1 mei 1964 draaiden de ontwikkelaars van BASIC het eerste programma gemaakt met de programmeertaal, gebouwd om het maken van computerprogramma's eenvoudiger te maken.

Eerste programma in BASICHoogleraar John Kemeny nam het initiatief tot het maken van BASIC in 1963 en op 1 mei 1964 vond de eerste succesvolle test plaats met een programma in deze taal, schrijft de universiteit van Kemeny, Dartmouth in de Amerikaanse stad Hanover. Kemeny en een student testten op die dag hetzelfde programma tegelijkertijd en kregen hetzelfde antwoord terug.

BASIC staat voor Beginner's All-purpose Symbolic Instruction Code en was bedoeld om studenten buiten de faculteiten van wetenschap en wiskunde in de gelegenheid te stellen om computerprogramma's te maken. Kemeny maakte BASIC gratis beschikbaar om het zich snel te laten verspreiden.

In de jaren zeventig beleefde BASIC de hoogtijdagen tijdens het verschijnen van de eerste computers voor thuisgebruik. De Altair 8800 draaide een implementatie van BASIC gemaakt door Microsoft-oprichters Bill Gates en Paul Allen, terwijl de Apple II ook een variant van BASIC ondersteunt. Er bestaan nog altijd toepassingen van BASIC-varianten, al is het niet zo invloedrijk meer als voorheen.

Moderatie-faq Wijzig weergave

Reacties (191)

1 2 3 ... 6
Ik wil toch even deze linken, een game geschreven in QB64: http://www.blackannex.net/

Binnenkort op Steam ;)
Check je code hier even voordat je hem post :D
Geweldig! Meteen weer zitten grutten in mijn grijze massa hahaha!
Is het erg als je nog weet dat POKE 53280 en 53281 , 0..15 de binnen en buitenrand qua kleur instelde op een Commodore 64?
Ik meet hieraan altijd mijn dementeer-waarde :+
Het hele POKE en PEEK gebeuren daar zie je in de huidige talen niks meer van terug :) Maar de oude Commodore 64 en Atari 800 code stond er vaak vol mee om dingen af te vragen of dingen uit /aan te zetten. Cursor uit, auto repeat uit, kleuren zetten of geluid hahaha...
Dat heeft niets met de taal te maken, en alles met het platform. Op een Commodore 64 moest je dit soort dingen instellen door op een geheugen adres te schrijven, op modernere platformen is daar gewoonlijk een API functie voor.

Sommige talen kunnen het nog steeds:
Basic:
POKE 53280 3
C(++):
*(char *)53280 = 3;
Dat heeft niets met de taal te maken, en alles met het platform. Op een Commodore 64 moest je dit soort dingen instellen door op een geheugen adres te schrijven, op modernere platformen is daar gewoonlijk een API functie voor.

Sommige talen kunnen het nog steeds:
Basic:
POKE 53280 3
C(++):
*(char *)53280 = 3;
En dat levert je op moderne platformen een prachtige Access Violation op.

Bij de oude machines was het nog mogelijk om rechtstreeks naar een geheugenadres te schrijven en daardoor op bit-niveau tegen hardware aan te kletsen. Met wat assembly kon je heel snel bitjes blasten naar de SID-chip, en dat was voor dit soort gegoochel ook wel nodig:

http://www.youtube.com/watch?v=bYQ9zUWVG4o

Tegenwoordig hebben alle besturingssystemen een beschermingslaag ertussen om te voorkomen dat programma's en virussen direct tegen de hardware gaan praten en andere programma's om zeep helpen.
Ooit heb ik nog een keer een progje in elkaar gedraait om de lpt poort van een win95 bak rechtstreeks aan te sturen en uit te lezen.

ging dit dan ook al via api of ook nog rechtstreeks in het register?
Ooit heb ik nog een keer een progje in elkaar gedraait om de lpt poort van een win95 bak rechtstreeks aan te sturen en uit te lezen.

ging dit dan ook al via api of ook nog rechtstreeks in het register?
Als je dat rechtstreeks via poort 0x378 deed dan zat Windows er niet tussen en elke byte die je daarnaartoe schreef kwakte ie gewoon op de ISA-bus en uiteindelijk de printerpoort uit ;)
Op de commodore 64, poke 808.1 was om het toetsenbord / programma te vergrendelen, break of ctrl-c of esc deden dan niks meer, erg leuk als de commodore 64 in de aula van de school toegankelijk was, dan was het:

10 poke 808.1
20Print "hans is een hansworst"
30 goto 20
40 end

en dan: run

Als ik mij goed herinner... is al meer dan 20 jaar geleden ;)

moest je de computer uit zetten om uit de loop te komen.. laat die aan en uit schakelaar nou niet werken op die c64 die daar stond en de stekker alleen toegankelijk met een sleutel.... Had de congierge pas na dagen door dat wij elke keer de c64 vast zette met een ludieke tekst op het scherm.

[Reactie gewijzigd door BenGenaaid op 1 mei 2014 17:28]

Met Poke 649,0 zet je het toetsenbord (ook) uit op de c64. Die code zit al meer dan 30 jaar in mijn hoofd. 8)7
Op single user, single task platformen was directe geheugen en I/O toegang meestal wel mogelijk. Denk aan DOS.
Onder Windows 9x was directe I/O toegang nog mogelijk, maar op latere platformen is dit, om veiligheids en stabiliteitsredenen, niet meer mogelijk.
Op single user, single task platformen was directe geheugen en I/O toegang meestal wel mogelijk. Denk aan DOS.
Onder Windows 9x was directe I/O toegang nog mogelijk, maar op latere platformen is dit, om veiligheids en stabiliteitsredenen, niet meer mogelijk.
Dat komt ook omdat Windows 9x in beginsel nog altijd een real-mode besturingssysteem was. Er waren wel wat grappen uitgehaald om andere processen te beschermen, maar het was feitelijk nog altijd een veredelde MS-DOS met Windows 3.11.

Pas vanaf Windows 2000 zijn ze overgestapt naar een beschermde kernel net zoals in Linux, dat was de kernel die van Windows NT was overgenomen, en die ze nog steeds gebruiken. (Windows 8 heeft als orfficiëel versienummer Windows NT6.0).

Windows Me was de laatste stuiptrekking van de DOS6.22/Win95/Win98 reeks. :)
Dat komt ook omdat Windows 9x in beginsel nog altijd een real-mode besturingssysteem was.
Windows 95 was een volwaardig 32-bit protected mode OS, maar had de (onzalige, en instabiele) feature om zichzelf naar 16-bit real mode (DOS) te kunnen 'thunken', en weer terug, als een soort van primitieve hypervisor/VM.

Het idee dat Windows 3.x/95 'bovenop' real mode DOS draait klopt architectureel niet, het had altijd zijn eigen geheugen management, kernel, low-level I/O toegang en API (eerst 16-bit "standard mode", daarna 32-bit "protected mode").

[Reactie gewijzigd door Dreamvoid op 1 mei 2014 19:12]

[...]

Windows 95 was een volwaardig 32-bit protected mode OS, maar had de (onzalige, en instabiele) feature om zichzelf naar 16-bit real mode (DOS) te kunnen 'thunken', en weer terug, als een soort van primitieve hypervisor/VM.
Dat is niet echt een hypervisor te noemen, als het een hypervisor is, dan wordt er een real-mode omgeving voor die applicatie gesimuleerd, en draait de CPU zelf nog altijd door in protected-modus. Windows NT kon dat wel (en kan het redelijk goed zelfs), maar in Win95 werd er op de CPU van context geswitcht.

Een 16-bit programma gooide de hele protected mode overhoop en kon alles in ring 0 van de CPU draaien (voor zover je op 386/486 CPU's van ringen kon spreken). Windows bleef wel in het geheugen maar er werden nog maar weinig instructies van uitgevoerd.

Als er een 16-bit DOS applicatie draaide werd het ook best een uitdaging om nog te multitasken. ;)

(Ik heb het trouwens niet over 16-bit *Windows* applicaties die voor Win3.x waren ontwikkeld, die maakten gewoon gebruik van de nog aanwezige oude APIs.)
Het idee dat Windows 3.x/95 'bovenop' real mode DOS draait klopt architectureel niet, het had altijd zijn eigen geheugen management, kernel, low-level I/O toegang en API (eerst 16-bit "standard mode", daarna 32-bit "protected mode").
De Win95 'kernel' is meer te vergelijken met een hoop van de memory managers van die tijd zoals QEMM32 en DOS4GW die een DOS 'protected mode' omgeving aanboden waarop een applicatie kon worden gestart. DOS zelf had weinig wat je een kernel kon noemen,, dus een eigen kernel daarbovenop bouwen was niet bijzonder moeilijk.
Win95 was natuurlijk wel wat meer dan enkel een simpele DOS4GW-achtige memory manager, 32-bit I/O drivers, een compleet 32-bit driver model, applicatie framework met Win32 API, etc.

Wat ik meer probeer te zeggen, er lijkt het beeld te zijn dat Win95 iets 'bovenop' DOS is, terwijl het feitelijk twee gescheiden OSsen waren waartussen (op brakke en instabiele manier) geschakeld werd.

[Reactie gewijzigd door Dreamvoid op 1 mei 2014 21:24]

hoe kom je van basic op win95 uit?

De windows kernel is compleet in assembler geschreven voor x86 en x64 machines :)
hoe kom je van basic op win95 uit?

De windows kernel is compleet in assembler geschreven voor x86 en x64 machines :)
We hadden het over het verschil tussen de 'oude' machines die op BASIC draaien en waar je met een POKE instructie rechtstreeks op een geheugenadres (en tegen de hardware) kon schrijven.

Dat lukt je in een modern OS (Windows NT, Linux) dus niet.

En dat de hele kernel in x86 assembler is geschreven durf ik te betwijfelen, er zal vast een hoger niveau taal bovenop gezeten hebben zoals C....
Ik dacht dat Vista NT 6.0 was, 7 NT 6.1 en 8 NT 6.2.

En WIndows 9x is absoluut niet Real Mode. Als het Real Mode was, zou het op een XT kunnen draaien, maar de minimale eis (iig voor 95) was een 386. Dit wijst op de 32-bits protected mode. (Er bestaat ook een 16-bits protected mode)

Onder Windows 9x konden programma's crashen met een Access Violation. Dát is dus duidelijk iets wat alleen in een Protected Mode kan, en nooit in Real Mode.

(Windows 2000 is trouwens gewoon NT 5.0)
Het hele POKE en PEEK gebeuren daar zie je in de huidige talen niks meer van terug
Omdat BASIC geen pointers kent heb je PEEK en POKE nodig om geheugen te lezen en schrijven. Recentere high level talen staan niet toe dat je willekeurige geheugenadressen uitleest en schrijft, maar in talen als C en C++ kan dat natuurlijk wel gewoon middels pointers. Een "PEEK 53280" zou in C gewoon "*(char*)53280" zijn, en "POKE 53280, 1" is "*(char*)53280 = 1"
[...]

Omdat BASIC geen pointers kent heb je PEEK en POKE nodig om geheugen te lezen en schrijven. Recentere high level talen staan niet toe dat je willekeurige geheugenadressen uitleest en schrijft, maar in talen als C en C++ kan dat natuurlijk wel gewoon middels pointers. Een "PEEK 53280" zou in C gewoon "*(char*)53280" zijn, en "POKE 53280, 1" is "*(char*)53280 = 1"
En een pointer is geen "willekeurig" geheugenadres?

Dat is namelijk ook niks anders dan een 32-bit integer die toevallig overeenkomt met een plaats in het geheugen, meer magie zit er echt niet achter.

BASIC kende heel weinig datatypes, maar een integer als pointer gebruiken kon prima.

10 FOR X = 2000 TO 4000
20 POKE X, 0
30 NEXT X

is gewoon geldige code om een blokje geheugen op nul te gooien. In C wordt het equivalent gewoon memset((char *)2000, 0, 2000), wat onder de motorkap dezelfde instructies uitvoert. :)

[Reactie gewijzigd door Stoney3K op 1 mei 2014 19:11]

En een pointer is geen "willekeurig" geheugenadres?
Beweer ik dan anders? Ik zeg dat recentere high level talen het niet toestaan. Daarmee doel ik op talen als Java en C# (al is het in C# technisch wel mogelijk in unsafe mode). Het zijn vooral de wat oudere high level talen als C, C++ en Pascal die toestaan dat je direct met kale pointers werkt. Voor de rest herhaal je eigenlijk precies wat ik al zeg.

[Reactie gewijzigd door .oisyn op 1 mei 2014 21:13]

Mogelijke reactie 1:
Met een (byte) pointer heb je ongeveer dezelfde functionaliteit als PEEK en POKE. (Tegenwoordig kun je, vanwege protected mode en aanverwante nieuwerwetsheid, een heleboel "typische" PEEK/POKE trucjes op je buik schrijven omdat je geen toegang meer hebt tot memory-mapped hardware registers en OS geheugen.)

Mogelijke reactie 2:
En da's maar goed ook, wat een ranzige code was dat altijd! :X Tegenwoordig heb je voor dat soort toepassingen gewoon een API met een fatsoenlijke naam en, hoe luxe wil je het hebben, documentatie en fout-afhandeling! :)
Nee, dat is niet erg... ;) SYS 64738
SYS 64739 was leuker, daar hebben we bij diverse winkelketens die de Commodore's op een rijtje hadden staan met de powerknop eruit, aardig lopen zieken. Dan stond ie meteen in Freeze.
Goh, wat waren we toen een stel puberale terroristjes...
POKE 120,0 was ook een leuke, die zorgde ervoor dat return nog wel naar de volgende regel ging maar helemaal niets meer uitvoerde...

Ik heb 'm ooit op school toegepast, eerst vers opgestart, toen POKE120,0 en vervolgens weggeveegd... uiteraard net voor een nieuwe les :+
Ik was de eerste die een programma schreef op de C64 welke een foto nam van de leraar...
Hij geloofde er geen snars van.
Toen had je nog van die groen fluoricerende monitoren.
Alles VOL qua helderheid en contrast, de kleur donkergrijs was toen helder wit, kun je je wel voorstellen wat volledig wit voor resultaat had.
...
Ga recht voor het scherm staan
Druk op spatie om foto te nemen
...
FLITS!
...
Vervolgens met van die speciale tekens een gezicht getekend.

E Voilá, foto! }>
Ik ook. En 49152, dat was c000, het begin van het vrije RAM. 53280 zat aan het begin van het gebied dat de VIC-chip besloeg
Ik ook. En 49152, dat was c000, het begin van het vrije RAM. 53280 zat aan het begin van het gebied dat de VIC-chip besloeg
En de SYS-instructie was ook niks anders dan BASIC afsluiten en naar het adres springen wat je had opgegeven.

Je killer-assembly-apps starten was daardoor ook poepsimpel.
Is het erg als je nog weet dat POKE 53280 en 53281 , 0..15 de binnen en buitenrand qua kleur instelde op een Commodore 64?
Ik meet hieraan altijd mijn dementeer-waarde :+
Nee hoor, niet erg. :)

Net zoals dat ik Poke-1,170 hanteerde om het geheugen van een MSX2 in te delen als een MSX1 zodat MSX1 games van tape of disk konden worden geladen. :P

Of een MSX weer vanaf 0 laten herstarten (msx 2 geeft dit het opstart/bootscherm weer)

DEF USR = 0: A=USR(0)

*reboot* ;)

[Reactie gewijzigd door Funk76 op 1 mei 2014 16:07]

Eerste twee getallen waar ik aan dacht. Waarschijnlijk de laatste twee dingen die ik nog weet als ik uitgedementeerd ben ;)
Je kunt nog even mee, die geheugenlocaties zijn correct. Tenminste, zo herinner ik het mij ook.
Als je een spelletje wilde spelen op de commodore 64 moest je eigenlijk altijd een mini scriptje schrijven in BASIC:
LOAD "", 2
En dan drukte je op play :)
Ik heb eigenlijk nooit geweten waar die ,2 voor stond.
,2 is toch het device? ,8 voor de floppy?
Precies, ik moest altijd ,8,1 erachter typen... }>
LOAD "*",8,1

Laad • het eerste bestand van [8] floppy en [1] start op het geheugen adres opgegeven in de eerste twee bytes van het bestand.

Je wordt ouder papa! :D
Geen Final Cartridge?
Power cartridge !! :-)
Volgens mij gaf je met die 2 aan van wat voor apparaat hij moest gaan laden . tape of floppy.
Awesome, dat was het natuurlijk!
Antwoord hieronder al, dank :)
Het getalletje achter de komma was het devicenummer.
1 was de datassette, 8 was de eerste floppy drive.
2 was niet standaard. Ik denk dat je een Power Cartridge had, die gebruikt 2 als een pseudo-device voor snelladen van tape.
Was het niet >
load "$" ,8, 1 of zo iets!!
Jeejee......

Was je dan niet super user?
En je tape kop weer recht draaien
Leuk man dit
Als je tape errors kreeg dan met een velletje papier tussen het deksel proberen en dubbelvouwen tot het wel werkte..

Na 10 minuten laden een error..

15 orf meer paginas hex codes intypen voor een spelletje dat 'bliep' deed..:D
Dat is het commando voor het opvragen van de directory.
Die 2 is het device number, als ik naar de syntax kijk:
LOAD ["<filename>"] [,<device number>] [,<secondary number>]

bron: http://www.c64-wiki.com/index.php/LOAD
De device waarvan je het wilde laden.
In dit geval de tape recorder of de floppy drive.
Heb nog steeds een commodore 64 met Floppy drive hier op mn Full HD led scherm :)
https://scontent-a.xx.fbc...75739577_1564611769_o.jpg
En nog steeds wordt BASIC niet als een volwaardige programeertaal gezien door velen., Als je zegt ik programeer in BASIC dan kijken ze je altijd een beetje minderwaardig aan. Nee dan in C#, Python e.d, veel beter hoor je ze dan zeggen...

Gebruik nog steeds veel VB6 of VBA of voor me retro computer collectie GFA Basic, daar krijg ik alles nog steeds mee voorelkaar. En vaak heel snel ff een setup maken...
Blijft leuk om te doen, ook al is het erg basic ;)
Bij ons op de dienst heeft iemand de afgelopen jaren enkele simulatoren gebouwd op basis van enkele oude embedded 486 systemen. De software om alles aan te sturen is geschreven in qBASIC, er worden digitale in- en uitgangen mee aangestuurd via de ISA bus. Ik zal BASIC dan ook nooit meer als onvolwaardige programeertaal aanschouwen.
QBASIC was dan ook heel wat meer dan het originele BASIC.
qbasic kon je compileren en basic was een interpreter.

Dus qbasic was stukken sneller. maar nog steeds lachwekkend traag vergeleken bij 't in 1970 geintroduceerde C, waarop bijna al onze systemen draaien.
Er is wel een verschil tussen QBasic (de meegeleverde BASIC van MS-DOS, ter vervanging van het oudere GW-BASIC), en QuickBasic (een los commercieel product).
QuickBasic had wel een compiler, QBasic niet.
Verder ondersteunde QuickBasic ook inline assembly volgens mij (of assembly modules, of hoe zat dat?), waardoor de mogelijkheden in principe onbeperkt waren. QBasic ondersteunde dit niet.

[Reactie gewijzigd door Scalibq op 2 mei 2014 11:28]

VBA wordt nog steeds heel veel gebruikt, het is ws de meest laagdrempelige programmeertaal van allemaal, ideaal om kleine brokjes van je dagelijkse workflow te automatiseren zonder direct een volledige applicatie te hoeven opzetten (of een specialist a 300 eur/uur in te huren).

Maar goed, VBA heeft weinig meer met het originele BASIC te makeen.

[Reactie gewijzigd door Dreamvoid op 1 mei 2014 17:48]

Ik programmeer nog altijd in VB.Net

Je kan er precies hetzelfde mee als C# en de compiler van tegenwoordig produceert vrijwel dezelfde code. Dus performanceverlies ten opzichte van C# heb je eigenlijk ook nagenoeg niet.

En ik moet zeggen dat ik er een prima app voor Windows 8 voor heb geschreven...
Ah, BASIC. Een van de programmeertalen die goto gebruiken, het meest vervloekte statment allertijden :)
C en C++ hebben ook goto. Het is niet gebruikelijk ze te gebruiken, maar het kan wel, en heel soms is het de beste oplossing. En een try/except blok is niet zo heel anders dan een goto.
C en C++ hebben ook goto. Het is niet gebruikelijk ze te gebruiken, maar het kan wel, en heel soms is het de beste oplossing. En een try/except blok is niet zo heel anders dan een goto.
Daar zit toch echt wel verschil in. Een catch{} blok is meer vergelijkbaar met het CALL statement in BASIC, waarin de CPU zijn huidige context (registers, program counter) opslaat en dan pas de sprong uitvoert, zodat je nog terug kan als alles is afgehandeld.

Bij een GOTO springt ie blind naar waar je naartoe wil zonder dat je op een manier terug kan.
Nonsens, bij een catch vindt een complete stack unwind plaats en is het dus niet mogelijk om terug te gaan naar de oorsprong van de exception. Dit houdt voor C++ bijvoorbeeld ook in dat destructors voor objecten op de stack worden aangeroepen. Hierdoor is het relatief eenvoudig exception safe code te schrijven.
Nonsens, bij een catch vindt een complete stack unwind plaats en is het dus niet mogelijk om terug te gaan naar de oorsprong van de exception. Dit houdt voor C++ bijvoorbeeld ook in dat destructors voor objecten op de stack worden aangeroepen. Hierdoor is het relatief eenvoudig exception safe code te schrijven.
Dat is nog altijd niet hetzelfde als een simpele GOTO instructie, waar gewoon de program counter wordt verzet en de rest (registers en stack) hetzelfde blijft.

Juist het in stand houden van die context is de reden waarom GOTO een heel smerige instructie is waar je gemene hacks mee uit kan halen.
Ik zeg ook nergens dat het wel hetzelfde is, ik reageerde op je stelling dat het op een call lijkt, wat absoluut niet zo is.

Overigens klopt wat je nu zegt ook niet helemaal. Zo zal een goto in C++ wederom de relevante destructors aanroepen, en is het niet toegestaan om over de intialisatie van een lokale variabele heen te springen. Alles bij elkaar heeft het throwen van een exception die gecatched wordt dus veel meer overeenkomsten met goto dan met het aanroepen van een functie. Wat dat betreft ben ik het eigenlijk wel met de stelling van ATS eens.

[Reactie gewijzigd door .oisyn op 1 mei 2014 21:43]

Och, C11 ondersteund het ook :P
Het gebruik van goto is een slechte gewoonte van de programmeur. Je kon dit prima vervangen door gosub... return constructies te gebruiken en in latere versies als Borland TurboBasic en Microsoft QuickBASIC 4.5 door subroutines sub... end sub.

Ik vond het vervangen van regelnummers in lables een verademing in de goedkope Basic compilers. Dit kwam de structuur binnen je programma aanzienlijk ten goede.

Oh ja, MCM werd op een gegeven moment een MSX/PC blad en is uiteindelijk geëvolueerd tot PC-Active. Wie is er nu niet groot mee geworden? De hoogst interessante collumn van Henk van de Kramer "PC-Lab" ;)
Ook in C is goto soms sneller dan met switch+break constructies werken :)

Bovendien is de processor beter in predicten dan :)

Als je weet wat je doet is goto geniaal. 1 van de goede dingen van BASIC door C / C++overgenomen :)
Als je weet wat je doet is goto geniaal.
Ja, de goto instructie verwijst (c.q. springt) naar een regelnummer of label en zet een bit op de stack (het stack register), om het er vervolgens nooit meer vanaf te halen.

Net als bij een kaartenhuis kwam daar op een gegeven moment het fatale bit en tuimelde de boel in elkaar.

Nee echt, wat een "geniale" programmeer methode. Je weet in ieder geval zeker dat het vroeg of laat crasht. 8)7
Ik kan me nog wel een cassettebandje herinneren met allemaal spelletjes geschreven in BASIC. Die moest ik dan in mijn supersnelle Sharp MZ-700 doen maar ik deed 'm tot groot ongenoegen van mijn moeder ook wel eens in de stereo :D
Haha die hadden wij ook. Snake&Snake, ManHunt, Land Escape, geweldig!
Alleen waren die volgens mij niet geschreven in Basic, maar in machinetaal. Voor Basic had je weer een ander bandje :)
Wij deden hem ook in de stereo... Dubbel cassette dek, was heel makkelijk spelletjes uitwisselen met de buren!

Mijn eerste programmeer ervaringen opgedaan op de Apple IIe van m'n vader. Computer spelletjes stonden toen nog in een boek...
Wie hier heeft destijds ook listings boeken gekocht om dat letterlijk uren lang over te typen en dan te ontdekken dat het dan niet werkte?
Och man :) En elke week weer naar de bibliotheek voor andere boeken. Duizenden regels code die voor een nét andere Basic-versie geschreven waren, en er werkte inderdaad niks :)
de kunst vond ik om het wel werkend te krijgen ;)
Klopt, maar aan je username te zien ben ik tien jaar jonger en was daar nog niet zo bedreven in ;)
was ik ook niet, maar met een hoop geduld en urenlang turen naar de TV (monitor had ik toen nog niet) vond ik de foutjes: komma's die punt-komma's moesten zijn en vice-versa

Hoewel de handleidingen wel veel meehielpen op ATARI Basic!
En een boek die ik in de bieb vond over GW-BASIC met alle statements-operators enz.
Er stond hier het een en ander bij de bieb. En op school waren er wat brouwsels in de omloop. Wat een hell was dat trouwens: een vol A4-tje met BASIC code overtypen waarop alle opdrachten samengevoegd waren met dubbele punten tot een bak onleesbare meuk. Maar ja, typen op zich was als 12-jarige ook nog een probleem en die GWBASIC "IDE" was ook niet bepaald ideaal.
Later heb ik nog vrij veel VB 1.0 voor DOS gebruikt. Dat was een reuzensprong, copy/paste, .exe's compilen, meerdere venters en bestanden tegelijk geopend hebben, en echte functies. Oh nee, subs :+. Er zat ook een op ASCII gebaseerd Windows/Forms systeem bij, vergelijkbaar met Turbo Vision van Pascal maar dat heb ik nooit gebruikt.

[Reactie gewijzigd door blorf op 1 mei 2014 17:29]

en uitzendingen van de radio opgenomen op zaterdag om vervolgens met een schroevendraaier je cassette af te stellen zodat je de code kon inladen..
ow ja..
ja ikke!!!!! grmbl!!
Viel wel mee, bij tijdschriften kwamen op een gegeven moment speciale intypprogramma's met checksums. Werkte prima.
10 FOR A = 1 TO 15
20 COLOR A
30 PRINT "BASIC 50 YEARS! "
40 NEXT A
50 GOTO 10
30 PRINT "BASIC 50 YEARS! ";

Met de ; erachter wordt je hele scherm gevuld, anders krijg je alleen maar een kolom vol :)
Inderdaad! De goede oude tijd !
Een comma doet alleen een soort van TAB afstand, je t moet dan een ; gebruiken wil je echt het hele scherm vullen.
Zo, heb wat afgeprogrammeerd in basic. Uiteraard op de ZX80/81/Spektrum/Spektrum128, ook op de Atari-ST in div soorten en ook op de PC in GW basic en Turbo Basic. Visual Basic was in mijn ogen geen Basic meer....
De eerste versie BASIC waar ik mee gespeeld heb was Tandy TRS-80 Model 1 Basic (12K ROM code). Daarna heel veel met MBASIC onder CP/M gedaan. Ik heb het hier nog steeds liggen, kan het opstarten in een CP/M emulator

BASIC-80 Rev. 5.21
[CP/M Version]
Copyright 1977 - 1981 (C) by Microsoft
Created: 28-Jul-81
31712 Bytes free
OK
_
Ik begon ook met een TRS-80 Model 1. Daarna kwam vrij snel een Commodore 64, daarna een Amiga, daarna een tijdje nix (in 1992 ben ik in Delft gaan studeren, en die eerste jaren had ik effe helemaal geen zin in computers in m'n vrije tijd!)
Ha, nog twee TRS-80 gebruikers! De mijne heb ik nog steeds, Model 1 Level 2 met Expansion Interface en twee floppies. In geen dertig jaar gebruikt maar laatst weer opgebouwd en zonder probleem de oude floppies kunnen booten. NewDos80, TRSDOS en LDOS 5.1.3, alles werkt nog. Goeie ouwe tijd!!

Toendertijd was er een grote community rondom de TRS80 Gebruikers Vereniging, ruim 5000 leden met als hoogtepunt de jaarlijkse bijeenkomst/markt in De Flint. Die gebruikersvereniging bestaat nog steeds.....
Gaan we nu met vier man zijn? Hier in huis ook een Model 1 Level 2.
1 2 3 ... 6

Op dit item kan niet meer gereageerd worden.



Apple iOS 10 Google Pixel Apple iPhone 7 Sony PlayStation VR AMD Radeon RX 480 4GB Battlefield 1 Google Android Nougat Watch Dogs 2

© 1998 - 2016 de Persgroep Online Services B.V. Tweakers vormt samen met o.a. Autotrack en Carsom.nl de Persgroep Online Services B.V. Hosting door True