starting off

[Joey]

so i shouldnt learn visual basic 6?

[Tim]

If you've got Visual C++ you might as well use it.

[slacker]

the order i learned languages:

1. qbasic -> making my hello world app & messing with already written program source
2. vb -> making those infamous aol proggies in private room VB
3. c\c++ -> learned in school
4. visual c++ ->making a basic window but vb is better than this cause it takes a page of code to make a window in vc++
5. assembly -> trying to make my own kernel

[Joey]

i didnt find the vc++ book i have too helpful :-\ when i used to work on it. im not sure what to do. i think im gonna do vb6 cause i can still make games and stuff, and i already know agi, so c++ wont be too difficult after that. im still not sure yet.

[kerim]

If you're working under DOS environment than learn Pascal, but if you work under Windows environment, then learn Delphi.

[Andrew_Baker]

I learned C with the C programmer's Bible (All ANSI-compliant functions in one book) and The C Programming Language by Kernigan and Ritchie (1975ed). I highly recommend the latter, as it is small enough to fit in a large pants pocket.

[AGI1122]

I myself started with QBASIC, then moved into AGI, mext I moved into PHP, and then PERL.

I do know a little C++/Visual Basic, but not enough to say that I am a guru or anything in them.

[anubis]

I started off with BASIC, moved onto C, then learned C++.

I then taught myself PERL, TCL/TK and some Assembly , learned Pascal, Prolog, Java & VB in college. My favorite language is C++ in its visual form that is Visual C++.

[df]

mm i started with c64 basic then 6502 assembler (c64).. then some miggy asm (miggy didnt last long).. straight into x86 asm, then c/cobol/sql/vb/c++/php/delphi/fortran/lisp/dcl/inform all in the same rough period of time.

i'm more rooted in asm than anything. c being my primary language when not at work, at work its all sql+vb and java.

[Joey]

see, so people went from basic to c, so ill do vb to c++.

[The Pro from Dover]

Must... resist... urge... to... prostelytize... weird... languages...

Sorry, I have to say it: I still recommend going through How to Design Programs first, with the free Dr Scheme IDE. While it isn't widely used, Scheme has the advantage that there isn't much of a language to learn; you can concentrate on understanding programming concepts rather than spending your time coming to grips with the syntax. Once you understand the basics of programming, learning any given language is relatively easy, whereas mastering a particular language may or may not give you the general knowledge to become a truly expressive programmer.

Besides, as I've said before, it's fast, and free; assuming you have a reasonably fast connection, and have the free time, it shouldn't be more than a month to finish the whole book, including all the excercises. While it is true that it starts out fairly simple, it gets into fairly heavy areas by the end.

Yes, it is a radically different style of programming language from either VB or C++, but this, too, is an advantage: it helps you see programming as something more than the act of writing code. As for good or bad habits, frankly, I would say that you are less likely to pick up bad programming habits in a LISP type language than in any procedural language I could name. But that's just me...

[The Pro from Dover]

Since I can't properly proselytize a language without at least one confusing example, I'll post this hex dump program I wrote in Scheme a while back:

Code: Select all

(define dump-file
;; read in a file and print a dump of it.
  (lambda (filename width height)
     
   ; display a number's ASCII value
    (define display-char-value
      (lambda (x)
        (display (char-value (modulo x 256)))))
    
    ; display a character's hex value
    (define display-hex-value
      (lambda (x)
        (let ((hexval (number->string (modulo x 256) 16))) 
          (begin
            (if (> 2 (string-length hexval))
                (display #\0))
            (display hexval)
            (display #\space)))))
    
    ;; display a line of character values
    (define display-line-values
      (lambda (dump)
        (for-each display-char-value dump)))
    
    ;; display a line of hex values
    (define display-line-dump 
      (lambda (dump)
        (for-each display-hex-value dump)))
    
    ;; display a line of hex values followed by 
    ;; a line of character values
    (define display-line
      (lambda (dump width)
        (let* ((size (length dump))
               (diff (- width size)))
          (begin
            (display-line-dump dump)
            (if (> diff 0)
                (do ((count diff (- count 1)))
                  ((<= count 0))
                  (begin
                    (display #\space)
                    (display #\space)
                    (display #\space)
                    )))
            (display #\space)
            (display #\:)
            (display #\space)
            (display-line-values dump)
            (newline)
            diff))))          
    
    ;; read in a line of data
    (define read-dump-line
      (lambda (src width)
        (let read-data ((count width))
          (if (or (>= 0 count)
                  (eof-object? (peek-char src))) 
              '()
              (append (list (char->integer (read-char src))) 
                      (read-data (- count 1)))))))

    ;; main function
    (if (and (string? filename)
             (> width 0)
             (> height 0))
        (let ((src (open-input-file filename)))
          (if (null? src)
              #f
              (let write-dump ((count height))
                (begin
                  (display-line (read-dump-line src width) width)
                  (if (or (<= count 0) 
                          (eof-object? (peek-char src)))
                      (begin
                        (close-input-port src)
                        #t)
                      (write-dump (- count 1)))))))
        #f)))

;; some support functions (usually in a spearate file)
(define hex->char
;; converts a character to a hex value
  (lambda (x y)
    (integer->char
     (string->number (string x y) 16))))

(define char-symbolic?
;; returns #t if the character is a symbol, #f otherwise 
  (lambda (c)
    (if (not (member c '(#\` #\~ #\! #\@ #\# #\$ #\% #\^ #\& #\* #\( #\)
                          #\- #\_ #\+ #\= #\\ #\| 
                          #\[ #\{ #\] #\} #\; #\: #\' #\" 
                          #\, #\< #\. #\> #\? #\/))) 
        #f
        #t)))

(define char-printable?
;; returns #t if a character is printable, #f otherwise
  (lambda (c)
    (or (char-alphabetic? c)
        (char-numeric? c)
        (char-symbolic? c))))

(define char-value
;; takes a character and returns its integer value
;; returns a period if given an invalid value
  (lambda (x)
    (let ((c (integer->char x)))
      (cond ((not (integer? x)) #\.)
            ((char-printable? c) c)
             (else #\.)))))

[The Pro from Dover]

So, Joey, what did you decide to work on, and how is it going?

[Joey]

so far vb6. i really havent had a chance to work on it for a few weeks, but i have some free time now to do so. so im gonna continue working with vb6.