AK

Person who turns out enormous amounts of pretty shoddy code that kind of 80% works, at a huge rate, and leaves a wake of destruction behind them. In many organizations, these people are considered heroes. This is who management goes to, when they need a feature tomorrow, and they will have a feature tomorrow, that works for most of the day tomorrow..Management actually rewards tactical tornadoes. 

I’ve come to realize that understanding pointers in C is not a skill, it’s an aptitude.

In first year computer science classes, there are always about 200 kids at the beginning of the semester, all of whom wrote complex adventure games in BASIC for their PCs when they were 4 years old. They are having a good ol’ time learning C or Pascal in college, until one day the professor introduces pointers, and suddenly, they don’t get it. They just don’t understand anything any more. 90% of the class goes off and becomes Political Science majors, then they tell their friends that there weren’t enough good looking members of the appropriate sex in their CompSci classes, that’s why they switched.

For some reason most people seem to be born without the part of the brain that understands pointers. Pointers require a complex form of doubly-indirected thinking that some people just can’t do, and it’s pretty crucial to good programming. A lot of the “script jocks” who started programming by copying JavaScript snippets into their web pages and went on to learn Perl never learned about pointers, and they can never quite produce code of the quality you need.

int x, y;     // x and y are integers
int *p;       // p is a pointer to an integer

var x, y int;    // variables x and y are integers 
var p *int;      // variable p is a pointer to an integer

int x, y;
int *p;
p = &x        // so far so good.
y = *p        // ???

var x, y int
var p *int
p = &x
y = *p       // de-reference p to get the value at the memory address it's pointing to

int* p;

int* p, q    // p is a pointer to an int, q is an int

var p, q *int 

func main() {
    grades := [3]int {1, 2, 3}
    change(&grades)
}

func change(grades [3]int) {
    grades[2] = 20 // caller doesn't see this change
}

void Modify(int[] data) {
    data[0] = 1; // caller sees this
}
void Assign(int[] data) {
    data = new int[20]; // but not this
}

func change(ptr *[3]int) {
    ptr[2] = 20
}

change(&arr)

package main

import (
    "fmt"
)

func main() {
    grades := [3]int {1, 2, 3}

    fmt.Printf("\nOriginal array:\n")
    for i, v := range grades {
        fmt.Printf("arr[%d] = %d\n", i, v)    // prints 1 2 3
    }

    change(&grades)
    fmt.Printf("\nModified grades:\n")
    for i, v := range grades {
        fmt.Printf("arr[%d] = %d\n", i, v)    // prints 1 2 20
    }
}

func change(ptr*[3]int) {
    ptr[2] = 20
}

func SliceDemo() {
    grades := []int{1, 2, 3}
    fmt.Println(grades)  // prints [1 2 3]
    changeSlice(grades)
    fmt.Println(grades)  // prints [1 2 20]
}

func changeSlice(grades []int) {
    grades[2] = 20
}