Qb Top 50....rumours and facts

By ZKman

Here's what you had to say about last month. Be sure and send us more letters soon!

Anyway, I have an idea for your magazine that might be cool. If you could make a reader proggie and have a special format for your articles so people could just download tehm and use the reader to look at them...I dunno, just a crazy idea. Anyway, keep up the good work.

Homeless

We were considering this, too, but couldn't think of any
format that would be small enough (in byte size). Any
suggestions, readers?

Thank you for changing the background colour to navy, but changing the text colour to silver makes it even more obscure. You could have used white (color 15). BTW, presenting the text in bold might help.

Amit Kumar Sharma

Looking at the issue that you are right now, it can't be denied
that we listen to our readers. 

I just found your site, and I instantly bookmarked it! This is great! A truly serious QB web magazine! And it's really good too! However, I read the following in the latest issue:

(News on Enhanced changing to DJCPP from last month's news)

Here the truth: You don't have to worry! We won't leave QB at all, even if we start programming in DJCPP too. Acutally, Angelo is the experienced one. I just started learning C++, and I don't even have DJCPP installed, so you can't say I'm the driving force behind his. And we have some really cool QB projects in the works right now, such as a (DELETED ON REQUEST ON ENHANCED CREATIONS...sorry! -ed).

Assembly language programming tutorial part 1: Getting started
By Petter Holmberg of Enhanced Creations

Hello everyone!
This article is written for all of you who wants to learn how to program in assembler in order to enhance your QuickBASIC programs. I know this is a dream for many QB programmers, but they feel it's too complicated to learn, and they haven't found any good sources of information to get started with. If you are one of these programmers, this article is written for you. You will find that it's not easy to learn assembly language programming, but you will probably also find that it's much easier than you first thought. This article will not delve too deeply into assembly language programming, but it will give you a solid start to work on.

So what is assembler then?
The early ancestors of today's computers, developed in the period of about 1940 to 1960, was a real pain to program. The circuits in these computers could perform simple arithmetic operations, they could take data as input, write data as output, and do other operations needed to solve problems for the people that had built them. In order to make the computers understand what they should do, they needed to be fed with instructions. These instructions was given to the computers as series of codes. Let's say the number 1 was the code for adding, the number 2 was the code for subtracting, and the number 3 was the code for outputting the result. The programmers would figure out a program, input it into the computer by turning switches or making holes in paper cards and feed them to the computer. If the program didn't work, the programmers had to go through each instruction again and see were the error was, and then reprogram the computer again. Not very convenient, especially as the programs were all written as a series of ones and zeroes. In order to make programming easier, they started writing the programs in hexadecimal numbers instead of binary numbers. That changed 4 binary digits into one hexadecimal, making the programs shorter and easier to read. But the programs was still just a sequence of numbers, hard to remember and understand for any programmer. So someone had the great idea that they would instead write the instructions as short words, that could be translated directly into numbers and fed to the computer. So instead of saying 1 for an addition, the programmers could say "add", and instead of 2 for subtraction, they could say "sub". Now you could see more clearly what the program did, and finding errors was not as hard anymore. The assembly language was invented.

Later on, computer engineers found out that you could actually make programming a lot easier if you rewrote long sequences of assembly instructions into codes much more like human language. They were called high-level programming languages, and BASIC was one of the first ones. Today's microprocessors still perform their dutys as a series of simple instructions, such as "add" and "sub", but programming languages like BASIC makes sure that we usually shouldn't have to worry about it.

Why do I need to learn assembler?
There are many reasons to use a high-level language like BASIC instead of assembler: A simple instruction such as PRINT could in assembler be more than 100 lines of code. It is therefore pretty obvious that BASIC programs are easier to write and debug, and you don't have to worry about what the processor actually does when it writes a letter on the screen. It just works. Another reason to use high-level languages is that you could easilly convert your BASIC program on yout PC to work on an Amiga computer, using an Amiga BASIC compiler. If you had wrote your program in assembler you would find that the Amiga wouldn't understand it, because it's CPU doesn't work like a PC processor. There are still reasons to use assembler instead of a high-level language: QuickBASIC cannot do everything. There are sometimes things you want to do with the computer that no BASIC instruction can do, and you often find that your BASIC program needs to do so many calculations that the program gets slow. The problem is that such an instruction as PRINT takes many possibilities into account. It makes sure you have a valid string to print, it checks what screen mode you use and what color you want to print the text in and so on. Usually you know all these details when you want to print the text, and you don't need the processor to perform all these checks. The only way to remove them is to use assembler code instead of PRINT. There's no point in writing a full program in assembler. Only use it when you need to do something really fast or something really low-level.

What do I need to know?
When you write a BASIC program, you don't really need to know much about how the computer works. In assembler you work with the computer on it's own level, and therefore you need to know what you're actually doing. You don't need to know very much to get started though, and you will learn the rest as you're learning assembler. The first thing that you will find useful to know is how to count in the binary and hexadecimal system instead of the decimal. This is pretty easy to learn. Usually we count in the decimal system. We then have 10 numbers, ranging from 0 to 9. The lowest number we could use is 0, and as we count upwards we use the numbers 1, 2, 3, 4, 5, 6, 7, 8 and 9. That's all the numbers we have, so in order to continue we need to use two numbers. We reset the 9 to 0, and add a 1 to the right of it. The first number is now worth 10 times the second one. We can now use all combinations of numbers up to 99, and then we need to reset them and add a third number. This suggests that the number 1234 can be expressed as 1*10^3 + 2*10^2 + 3*10^1 + 4*10^0. See the pattern? What if you didn't have 10 numbers to play with? Well, it works just as fine anyway. The binary system, on which computer technology is based, has only 2 possible numbers, 0 and 1. You start counting from 0, and when you reach 1 you have used all of your numbers and need to add a second one, and you get the number 10. Each new number is worth 2 times the number to the right. The binary number 10110 can thus be expressed as 1*2^4 + 0*2^3 + 1*2^2 + 1*2^1 + 0*2^0, or 22. The hexadecimal system works with 16 different numbers. Since we only have invented 10 symbols for numbers, we use letters to represent the higher numbers. The hexadecimal system therefore uses the numbers 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E and F. The hexadecimal number F3 can therefore be expressed as 15*16^1 + 3*16^0, or 243. It's easier to understand if we put the three systems in a table for comparisation:

Decimal         Hexadecimal     Binary
0               0               0
1               1               1
2               2               10
3               3               11
4               4               100
5               5               101
6               6               110
7               7               111
8               8               1000
9               9               1001
10              A               1010
11              B               1011
12              C               1100
13              D               1101
14              E               1110
15              F               1111
16              10              10000

As you can see, the number F in hexadecimal is the same as the number 1111 in binary, and this shows why the hexadecimal system is often used in assembly language programming instead of the decimal. If you want the binary number 1111000011110000, you can write it in hecadecimal as F0F0. As you can see, it's easy to convert binary numbers to hexadecimal and hexadecimal numbers to binary.

The number of different digits you can use is called the base of the counting system. You can use any number as a base. If your number in any counting system is, say, 3 digits long, it can be expressed as: a*base^2 + b*base^1 + c*base^0, where a, b, and c are your three digits. The most important thing when using different systems simultaneously is to keep track of what system you use for a certain number. For example, is the number 10 the usual decimal for 10, or the binary version of the decimal number 2? If you still haven't understood this, read it again until you do or ask someone who understands it to explain it to you. It's very useful to know about this when you program in assembler.

The second thing that is necessary to know when programming in assembler is the PC memory architecture. I'm not going to explain this in detail, because it's a complicated issue.

A PC has 640 kilobytes of basic memory, and additional megabytes in special memory circuits that you can insert into the computer yourself. The terms EMS and XMS refers to this extra memory. That is not the memory I'm going to talk about here. The interesting thing is the basic 640 kilobytes that every PC has. You need to know how to find a certain position in the memory if you want to use it, and you need to know how to do this if you are going to be an assembly programmer.

Each position in the memory have an address, a number telling the computer where to read or write data. It would have been easy if this addres would just have been a number from 0 to 640k, but that's not the system used. A memory position is described by two numbers, called the segment address and the offset address. The actual memory position is a combination of the segment and the offset address.

The segment address describes the memory as groups of 16 bytes. The first byte in the memory, byte 0 if you like, has the segment address 0. The segment address 1 is the 16th byte in memory, and the segment address 2 is the 32th byte in memory. The offset address is a number telling you how far from the segment position in memory the byte you want is. So if you want to access byte 3 in memory, you use the segment address 0, and the offset address 3. Together they form a number pointing at an exact memory position. Written as a formula this can be expressed as: actual memory address = segment*16 + offset. if you want to access byte 20 in the memory, you use the segment 1, giving you the position 16, and the offset 4, adding 4 bytes to the position, for the final number 20. But you can also use a segment address of 0, and the offset 20, giving you the same memory position! The segment and the offset address numbers can both range from 0 to 65535, giving you several possible combinations when you want to use a certain memory position. This system makes it a little complicated to understand memory addressing to beginners. You can see what segment and offset a certain BASIC variable is located at by using the functions VARSEG and VARPTR. Try it!

Now you might be wondering how it is possible for both the segment and offset variables to be 65535. That gives you the biggest possible memory position of: 65535 * 16 + 65535 = 1114095, which is bigger than 640k. Well, this memory certainly exists, but it is not accessible as the first 640k of memory, and I'm not going to delve deeper into this here and now. Later on, I will discuss memory access in more detail.

Again, if you didn't understand this, read it again, and if that didn't help, ask someone to explain it to you.

This was all for the first part of this article: A very brief introduction to what's about to come. The next time I will start describing the basics of assembler and how you use it in QuickBASIC. Make sure you understand the different numbering systems and the memory addressing scheme until then.

Bye for now!
(Editor's Note: Petter's asm series will continue in Issue 5. Check it out!)

Hey! Welcome to the Hall of Fame. Our first inductee left the qb community almost a year ago, but his work will never be forgotten. His games have inspired countless others, such as Dark Ages, but very few have been up to the standards of his crowning acheivement.

And what was that? 5 words:

Lianne in the Dark Crown

For a VERY long time, this was THE qbasic game...the one all others looked up to. With graphical standards that were unprecedented (this was in the time before Dash, Blast! and dqb), a fair plot, and lots of humour, as well as an innovative battle system, this game was the one that everyone played as soon as it came out.

I'm sure you all know now that I'm talking about DarkDread and his company DarkDreams, maker of Pong97, Legend of Lith, and Lianne... and the first entry into the qbasic: the magazine hall of fame! Congratulations!

Well, you've got QBASIC or QuickBASIC on your system. Finally.

*BUT*

Now what??????

Obviously this article is geared towards the extreme beginner, so if you've ever made your own scrolling engine, move on. In this article I will explain some of the most basic QBASIC commands. Read along, and by the time you're finished, you'll be writing your own programs, easily!

First off, the following are the different commands you will learn from this article:

SCREEN, PRINT, LOCATE, CLS, COLOR, INPUT, SLEEP

SCREEN : The SCREEN command changes the resolution and colors available to the screen of your computer. Ever noticed how DOOM looks really blocky compared to Windows? Thats becuase DOOM was made in a resolution of 320 pixels by 200 pixels. Windows usually is set at a minimum of 640 pixels by 480 pixels. A pixel is one 'dot' on the computer screen. In this article, I will only demonstrate SCREEN 13. Check the QBASIC/QuickBASIC help file for more info on screen modes.

PRINT : The PRINT command 'prints' a string of alphanumeric characters to the screen. In plain english that means that it puts words and numbers on the screen. Proper syntax is PRINT "alphanumeric character(s)" (include the " ").

LOCATE : The LOCATE command is used to tell the computer just where on the screen you want to PRINT something. It's proper syntax is LOCATE row, column with row and column both being numbers. The amount of rows and columns depends on the SCREEN mode, but it is generally 24 rows, and 80 columns. 1 letter or number will occupy 1 row,column space.

CLS : The CLS command does nothing more than clear the screen.

COLOR : The COLOR command changes the color of everything you PRINT to the screen. Proper syntax is COLOR n where n is the number of the color. Check the QBASIC help file for the different color codes.

INPUT: The INPUT command lets the user type in whatever they want, and it will save what they type to what is called a variable. Proper syntax is INPUT "Please type something in " , variable$ You can either leave out the "Please type something in" or leave it in, and you can define whatever phrase to use. variable$ is the variable which saves what the user types in. The $ at the end is to define just what type of variable it is, but I'll explain those later.

SLEEP: The SLEEP command makes the computer wait until the user presses a key. In effect, the computer "sleeps"

OK! Now I've showed you each command and what they do, time to show your skills! Here's an example program which uses all of the commands above.

SCREEN 13
COLOR 1
PRINT "Hello,
World!"
SLEEP
CLS
LOCATE 1, 14
PRINT "Hello,
World!"
SLEEP
CLS
INPUT "Whats your
name?", name$
CLS
PRINT "Hello, "
, name$
SLEEP
END

There! Isn't that program just wonderful? Notice how with PRINT "Hello, " , name$ you could print what the user typed? You can use this to make lots of cool programs!!!!

Oh yeah, I said I'd explain the different types of variables. Basically there are 2 important types for a beginner to remember:

% and $. % is for variables which are only used for numbers, while $ is for strings of letters and numbers. Thats all there is to know. Be sure to read through your QB help file, it contains even more info on all these commands! SO GET OUT THERE AND START PROGRAMMING! :p

...when the number of QB programs you've downloaded to your computer is triple that of NeoZones' QCity. I myself have downloaded at least 50MB worth of Zip files.

...when you have visited more QB-related sites than there are registered in the QB Top 50 and QB Top 25 combined. (But once you've seen my site, you'll never look at other sites again) =)

...when you have already emptied three bottles of Visine while chatting at #QuickBasic. I seen lots of people on #QuickBasic who never seem to leave at all...

...when you have repaired your PC countless times trying to integrate DirectQB, Dash, Blast!, BSWB, QMidi, and DMAPlay together in your game.Heheh, now here's a nice reason not to use libraries =).

...when you have everyone who has ICQ on your contact list--and pestering those who haven't to get one. As ICQ is one of the preferred means of communication among Qbers, so have sprung numerous ICQ-lists on the Net.

...when you have posted at least 10 articles in every QB discussion board.As Entropy says, Discussion boards on QB sites are as cliche as File sections.

...when you start using asterisks (*) and carets (^) in your math class.I even use SQR and ABS. How 'bout you?

...when you've registered your site to all the QB Webrings (and all other programming Webrings, for that matter). Some people will do just about anything to drive traffic to their site! =)

...when you can recite by heart the syntax of every QBasic command.Even then, it won't help you from making errors in you code! =)

...when your biggest flop in life is the time when you crashed your hard disk by accidentally poking into the wrong memory address. The number of illegal errors you get is inversely proportional to the amount of free memory for use in your program.

...when your game never gets finished since you keep on upgrading it to use the latest libraries. How many times has this happened to you?

...when you want to name your first-born son Eldim and your first-born daughter Sona. 'Nuff said.

...when you are already submitting entries to SonicBlue and Danny Gump for Qlympics 2000. Some people just can't wait to win the admiration of fans.

...when the number of minutes you've spent online is greater than the number of words of all of Tsu's rambles combined. Here's to the people comprising the QB Online Community!!! Keep the legacy alive!


Hope you've had a good laugh at this!

For the complete list, go visit my site at http://www.geocities.com/SiliconValley/Horizon/2586/.