The pointer is not a thing that every developer needs to know, but it's still a thing that exists. This question is kind of a stand in for concepts like pointers and not just that one thing.
I wonder: Do they teach this concept in bootcamp at all?
Should they teach stuff like pointers at all to a group learning, say, web development in JavaScript? If so, does it come early or late?
I imagine the course doesn't need to cover computer science from the ground up, but what should get detailed and when?
In computer science, a pointer is an object in many programming languages that stores a memory address. This can be that of another value located in computer memory, or in some cases, that of memory-mapped computer hardware. A pointer references a location in memory, and obtaining the value stored at that location is known as dereferencing the pointer. As an analogy, a page number in a book's index could be considered a pointer to the corresponding page; dereferencing such a pointer would be done by flipping to the page with the given page number and reading the text found on that page. The actual format and content of a pointer variable is dependent on the underlying computer architecture.
Top comments (34)
Joel Spolsky has a pretty radical point of view (not sure if I really share it, but it's interesting): The Guerilla Guide to Interviewing
Asking questions about pointers and recursion is apparently part of his interviewing routine, and one of the deciding factors for hiring someone
Now the question is, whether it's only crucial to good programming in C or higher level languages that abstract memory management away, but Joel seems to be saying: a good programmer understands pointers (and recursion). Bad programmers don't.
Interesting point of view, but not sure what to think about that 🤷
I'm not terribly convinced that this isn't a skill. It might be a skill that's difficult to acquire, and perhaps a skill that's difficult to retain or even be really good at. And maybe some people are just better at thinking about really weird problems.
But pointers aren't a hard concept, and probably everyone has used a pointer at one point in their life, without realizing that's what they were doing.
a href? Pointer
Library card catalog? Pointer
Yellow Pages? Pointer
Address book? Pointer
Table of contents? Pointer
Index? Pointer
The problem is that most people who understand pointers don't do a good job of teaching what pointers are.
I agree with you. In my opinion, pointers scare starters because of their bad reputation. In reality, the scary thing of pointers is that the errors they produce are difficult to track and debug, so you need some solid good practices.
But conceptually, they are not more difficult to understand than other data types out there.
When I was in bootcamp, we didn't learn about pointers per se, because the languages we learned (Ruby and JavaScript) didn't have pointers, but I do remember learning about the difference between passing by reference and passing by value, so when I learned Go and it came to pointers, the concepts were familiar to me.
In every high level language you're going to have the idea of references, like in JS if you do
If you understand that you'll see 42, then you understand pointers.
This code snippet reminded me of a mental model I acquired from Dan Abramov via his Just JavaScript newsletter, where we learned to literally "draw" pointers to understand the concept of references in JS.
I think pointers are pretty fundamental in programming, so understanding them might be a good idea even if you don't use them NOW (and it's a pretty basic concept tbh). You can't be sure you'd be writing JS (or any other language without pointers being present to the programmer) for life. I thought that I won't face them, but then I've started programming in Golang and here we go.
I'd suggest to learn as much as you can because every day it gets harder for your brain to learn, memorize and understand information.
Pointers in the sense of managing memory locations are probably not critical unless the language you use presents that interface.
But "pointers" in the more general sense of having a piece of data that refers to the "real" data in another location is fundamental and appears all over. (Think foreign keys in databases, URLs, file systems, compression formats, etc.).
You really can't do anything interesting on a computer without this idea.
I'll also throw in the concept of a pointer to a pointer. Which at first seems like a silly extension; but on second look can actually allow surprising simplifications of problems.
"All problems in computer science can be solved by another level of indirection" - David Wheeler.
No, people should not have to learn pointers if they are studying a high-level language because that is an internal feature in those languages - kind of how you have a transmission in a car but you don't need to know about it to drive.
Yes and no. Using your car analogy, the developer would be a mechanic working in the engine bay. They might be able to get by working only on parts not directly related to the transmission, might even be great at it, but would you not prefer a mechanic that understands all of the engine mechanics?
Similarly, abstract memory management might be obfuscated away in high-level languages, but it still happens. Understanding the mechanics of it will improve the efficiency of your code. Most high-level languages don't require you to manage the memory yourself, but that doesn't meant you don't need to keep memory usage in mind.
My first programming course was an Engineering-track "Intro to C++" class, back in 2000, as part of a CS major.
If I remember right, we didn't even touch pointers in that class - they were covered in the second course, "Object-Oriented Programming with C++".
I think pointers are a valuable concept to understand for anyone doing programming.
At the same time, I wouldn't teach C++ as a first language to anyone getting started today - I'd go with JS or Python. Along with that, no, I'd never try to throw a beginning programmer straight into pointers.
I do see some value in trying to cover something sorta-kinda like this somewhere in the process. After all, "references" in JS, Java, Python, and C# are just pointers that have been hidden a bit so you can't modify them yourself, and it's certainly important to know that this code:
just creates two variables pointing at the same array in memory.
Mmm... I'm actually kinda talking myself back and forth on this one a bit here as I write :)
Eh... if we're going to stretch the definition of "pointer" to "references in GC-based languages", then yes, I can see the importance of covering that at some point in the semi-early-ish learning process.
I think what people are trying to imply when they value pointer experience is knowledge of how the code controls the hardware memory. You do not have to use pointers to understand this, although the minutia of dealing with pointers does provide you with significant hints.
But the short-term benefit of being instructive does not outweigh the long-term maintenance hassle of being fiddly and error prone. Even garbage collection can teach you the memory model eventually, because you have to dig deeper when you run into its limitations.
Pointers, I would think no as you don’t really have to worry about those in higher level languages, however there are foundational programming paradigms that I think should be taught like separation of concerns, dependency injection etc, essentially how to write clean code.
No they don't (personal experience). Yes they should - incredibly useful concept. I'm of the opinion that a good code bootcamp should pivot to teaching Go; a simple language, but one that is explicit about the use of pointers/references.
Even in C++ people probably won't juggle complicated pointers. But they might cause a memory leak in Java. They should understand why and how.
If not the above, they should understand linked lists and I'm not sure how to explain that without talking about references which are basically pointers that are automatically dereferenced when being accessed.
The objective of a bootcamp is to get people quickly proficient in a particular technology. It's not a replacement for a Bachelor's degree.
I would suspect that if you interview to find out if the person understood their BS that you would filter out Bootcamp people. But then why are you even interviewing them?
Bootcamps are a tradeoff. Recursion and pointers are more in-depth.
When I designed a university curriculum I forced everyone to learn recursion and pointers (much to the initial horror of some). But when I designed a Bootcamp curriculum I preferred to teach concurrency, transaction isolation, and multi-threading that I thought was more relevant and urgent to teach in the limited time we had.
We couldn't teach everything. If you want everything you should do a BS not a bootcamp.
This is one of the things that can be very harsh with bootcamp and that makes a clear difference to someone who studied CS.
Bootcamps usually just focus on the language that your learning so Javascript the focus would be on node, react etc. But anything related to computing and general knowledge is not taught.
I have interviewed junior devs who came from bootcamps and asking question such as what happens when you type a url in browser (dns lookup, request reponse principal, transport layer etc)
If you want to create or modify binary files on disk or in RAM, then you will need to understand how pointers work. Here's a tutorial video I made recently on binary file structures:
There are some competitive programming bootcamps they must be teaching it.
And in higher level languages we can't directly access pointers but we generally use the concept of a reference, which is mostly implicit. So I guess going by the language is good enough. Pointers are really powerful in C and C++ but in Python or JS, we don't care a lot about them, pioneers of these languages don't want us to be bother about it.
We've covered them in our bootcamp! We're eight weeks into a ten month camp, and I think we learned about them in maybe week 6 or so. Not explicitly the concept of pointers, but ones related to what language we are learning (Ruby) and how they relate.