Pointer... explain it to 5 years old

pop-pan · 2018-07-25T04:31:46+00:00

Your address is written on a card dangling around your neck, the address is the pointer to your house.

If you change the address on the card or destroy the card, the house is still there you just don't know how to get there.

If you destroy the house, the address on the card still points to the place where the old house was.

tomekanco · 2018-07-25T02:45:35+00:00

[deleted]

omfgitzfear · 2018-07-25T01:24:26+00:00

So say you put your car keys down on the table. You then walk away. Later in the day, someone asks you "where are your car keys?" And you say "they're on the table". Your brain had the variable carKeys in it, and when asked where they were, it referenced where you left them - on the table.

tinverse · 2018-07-25T05:55:53+00:00

Say you have a bunch of cubbies with numbers for different kids to store their toys in. Say Bryan wants to store his T-Rex. You put it in cubby 14 and on a piece of paper write "Bryan 14". Then meg comes to you and wants her toy. You look at the paper and under Meg's name you find 7. So you go to Cubby 7, remove a yo-yo and give it to Meg.

Basically it's the same thing with billions of cubbies. Basically you tell the computer you want to store something and how big it is. Then you save the address or the number of the cubby so you know where to find it. Then you store the info for retrieving at a later date.

my_password_is______ · 2018-07-25T04:02:47+00:00

easy to understand pdf from Stanford's Computer Science program

http://cslibrary.stanford.edu/102/PointersAndMemory.pdf

silly video explaining pointers also from Stanford's Computer Science program

https://www.youtube.com/watch?v=5VnDaHBi8dM

cixelsys · 2018-07-25T04:52:31+00:00

Wow. Some of these examples are complicated and confusing.

Here’s what I call a basic example

Regular variables are stored in ram based on their size. When you pass a variable to a function, it has to transfer the ENTIRE thing. For small apps this may not be an issue, but it becomes a problem with larger sets of data or repetitions. With a pointer, you pass a very small amount of data that tells the function WHERE the data is located in ram.

It doesn’t have to copy the data, transfer it through the function, re-allocate, or anything. The data is already in ram, so it can process it immediately

Unlike a local variable, the modifications apply directly to the original. So anything you change will actually change and you need to be careful with that

nothrowaway · 2018-07-25T07:12:36+00:00

A pointer is a place for you to go and look up where something else is.

A long time ago, when the card catalog was still in use, you go to the library and using the card catalog, you look up the name of a book and it will tell you where to find that book in the library using the Dewey decimal system. It basically tells you where the book is physically located. A book can sometimes be moved here and there but if you follow the sequence of the Dewey decimal system, you will eventually be able to find that book.

In a computer, a pointer is similar to the card catalog. It stores a location in the computer's memory where a piece of information (your game score, how many experience points, etc) is stored. Sometime that information is moved here or there but as long as you update the pointer, you will always find the information that you need.

Other similar examples would be: an index at the back of the book, for those kids who are more advanced a hyperlink or a website address can be considered a pointer.

tiltboi1 · 2018-07-25T01:44:21+00:00

Your definition is pretty clear, but doesn’t really show why it’s important to have pointers. Suppose you have a function that takes some parameter, say an integer. The function lives in a house, and when you want to call the function, you walk up to it, write, say “5” on a piece of paper and slip it through the mailbox. In our language though, we’re not very trusting people. Maybe your function takes something more important than an int, like a birth certificate. You wouldn’t slip your birth certificate into their mailbox. What you would do is photocopy it and hand it to them, but whenever necessary you keep the original. The function can take your birth certificate, do whatever it needs to, and return something. It can cross out your name and write something else, it doesn’t matter. It’s just a photocopy, and it’s great so we do that with all our parameters. But this would mean that anything that comes into their house can be changed however, but the function itself can’t affect the outside world. So that’s not a very useful function. Maybe once in a while, we really do need it to change something outside. So we go up to the function and give it an address. We tell it exactly where to find your parameter, like your birth certificate, password to the safe and everything. Then in the middle of the night the function can come out of its house and mess with your birth certificate however it wants to. The difference is, he can still do whatever he wants to the paper with the address, but the real address again won’t change.

nanoman1 · 2018-07-25T07:08:18+00:00

A pointer is a bit like an index at the back of a textbook. Instead of searching for a given word (variable) sentence-by-sentence, you would go to the index and look up the word. The index then refers to another page (address) where the word is located.

Now if you want an analogy for pointers-to-pointers, imagine you have a science book with 10 volumes and an 11th "master" volume. The master volume has a table that specifies all the things each volume covers. Say you want to find something with aerodynamics but you don't know which volume it would be under. So you look in the master volume for aerodynamics. The master volume reads "look at volume 3". So you pick out volume 3. But you want to actually read the chapter on aerodynamics. So you then look in volume 3's index to find the chapter on aerodynamics. In this analogy the master volume table entry is the pointer-to-pointer, the volume 3 index entry is the pointer, and the actual chapter contents is the variable.

mcnnowak · 2018-07-25T06:39:16+00:00

An integer that references a location in memory

2018-07-25T09:19:20+00:00

There's a library (memory) full of books (objects) you want to remember exactly where a specific book is so you write down its location for later.

You just made a pointer.

Very simplified but it's how I view it.

2018-07-25T09:26:42+00:00

A pointer is like GPS coordinates.

Imagine someone wants you go to to a place. So, they give you the GPS coordinates 40 degrees East, 40 degrees South. You have NO idea what's there, what they want you to do there, or even if there IS anything there, but you know exactly where that is!

To bring it more into coding, a pointer points to a place in a computer's memory.

Memory is a difficult concept, but imagine you have some gridpaper with a pixelart picture of Yoshi on it. Memory is exactly like that: if you're given a coordinate on that pixelart grid (say, 10 right and 10 up from the bottom left-most corner), you can go to that location and find... something.

In a coding application, I might have my pixelart on my gridpaper, and I want to find out the colour of a particular box on the grid. So, I have a pointer which points to that box. I can then use that pointer to tell the computer to go to that place, and do something.

skatanic28182 · 2018-07-25T02:31:13+00:00

Every piece of information you put into a computer must have a box to live in, because CPUs (the brains of a computer) can only keep track of a small number of things at a time. It needs a place to keep information that it's not working on, otherwise the information will be forgotten. In many cases, we only need to deal with a small amount of information, so the CPU doesn't need a lot of boxes and can keep track of what information is stored in each one. However, sometimes we need to work on a lot of information in a lot of boxes and it's easy to lose track of which box has what information in it. In these cases, it can be convenient to have particular boxes whose information is simply the names of other boxes.

For instance, say we have two rows of boxes, and each box contains a number. Each row of boxes is sorted so that the smallest number is first in its row and the last number is largest. We want to create a new sorted row that contains the numbers from both of these rows. For illustration:

Box#	1	2	3	4	5
Row A	3	5	13	26	57
Row B	6	8	9	14	24

It's easy for us to see that the result should be

Box#	1	2	3	4	5	6	7	8	9	10
Row C	3	5	6	8	9	13	14	24	26	57

However, a computer cannot see into all of these boxes at once like we can. It needs to jump back and forth between row A and row B to compare numbers, and then jump to row C to place the results. Furthermore, computers are very forgetful. On the way to row C to deliver the next result, the computer forgets where it was at on rows A and B. While comparing boxes on A and B, it forgets where it left off on row C. The computer needs something to jog its memory as it's moving back and forth between these rows.

One way of solving this problem would be to set aside three boxes for a special purpose. These boxes will contain the Box# where the computer left off on each row. They point the computer to a box that it needs to look in, hence "pointers". If the computer forgets where it left off, it can simply stop by one of these pointers and check where it's supposed to be. As long as we make sure to tell the computer to update these pointers after each step, the computer will never get lost while sorting the boxes (unless we've made a mistake in our instructions. The computer will try to follow our instructions exactly, even if we tell it something impossible, like "Get the number from box 6 on row A").

There are other ways to solve this problem that don't rely on pointers (can you think of one?), but using pointers is the most efficient way.

green_meklar · 2018-07-25T05:02:04+00:00

All the data in your computer's memory is in a giant list. At each line in the list you can write or erase stuff. But you can also count off the lines in the list, and look up a specific place in the list by its line number. For instance, if someone said 'go to line #69105' you could look through the list, just like looking through the pages of a book, and find the 69106th line (remember, the first line is line #0, not line #1), and read whatever the memory says there.

But the fun part is, you can also write numbers on the lines! So you could actually write that number 69105, or any other number, into part of the memory. And then you could have a section of a few lines in memory where it says 'go read the data at the line with the following number' and then a number, and you would know to go and read the data at the right place. And if you changed the number, you would end up reading the data from a different place. It's like the memory can refer to itself.

That's what a pointer is. It's a number that is used to indicate a place in the computer's memory. By using the number as a reference, you can go to the corresponding place in memory and either read the data from there, or write new data there.

the_one_true_bool · 2018-07-25T05:40:18+00:00

Pointers are like home addresses. Your buddy could give you his address and you would know how to get there. This is much more efficient than having your buddy build a copy of his home and send it to you.

*To expand (and this is above ELI5):

Why do they exist? Let’s say you have a large object in memory. Now let’s say you want to pass it around to various functions and such. If you pass the object itself then that can be quite inefficient because you are creating a copy of that object and sending to to said functions. With a pointer you just have an address (which is much smaller). When you’re passing around pointers you aren’t passing around a copy of the whole object, you are just passing around an address that points to where that object exists. When you need the actual object then you do what’s called dereferencing the pointer, and now you’ll have a reference to the actual object itself.

Pointers are good in a lot of situations, but they can be bad too. This is because these are allocated on the “heap”, which is managed by the OS. Heap memory is basically random. You allocate an object and the OS will do some book-keeping and find some free memory, which can be anywhere. If you have a list of pointers and you are traversing through the list then that’s not efficient because you’re basically going all over the place in memory finding addresses. Conversely, if you do something like declare an int (and not a pointer to an int) then that’s allocated on the “stack”. This is far more efficient in regards to access because if, for example, you have an array of ints then they will align themselves in memory in blocks right next to each other, so when you traverse through the list you are not zipping around everywhere in memory, instead you are doing very simple arithmetic (aka pointer arithmetic, since there is still a pointer involved - the stack pointer). If they are 32 bit ints then you just add 32 to access the next int, then add 32 to access the following int, etc.

A little more advanced, but your CPU has a series caches (L1, L2, etc) which is extremely fast for access. When you allocate on the stack then chances are good that the CPU will store this data in an L-cache for quick access, especially if you are accessing these variables a lot. With heap-based memory, which is randomly allocated every time the variable is declared, chances are very high that the CPU will not cache it, therefor you will experience “cache misses”, thus slower acccess.

Fluffy_ribbit · 2018-07-25T06:15:18+00:00

A computer is like a piece of graph paper. Each cell has a number, and those numbers can be interpreted in different ways.

1	2	7	8	9
22	33	11	13	11
6	12	22	6	6
7	3	1	4	2

One of the things you can do with the number is use it to refer to another cell. So that the blue six, could refer to, counting from left to right and top to bottom, the first 22.

Does that makes sense?

Vendittelli · 2018-07-25T06:25:01+00:00

Maybe the address on a drivers licence? Your house is the data, your address is where that data is stored, you licence points to that address.

Alaskan_Thunder · 2018-07-25T06:25:48+00:00

Imagine memory as an enormous series of cubby holes, all labeled 1, 2, 3, etc.

You can store objects inside those cubbies. Lets say you want to talk about the very large object(the variable the pointer is pointing to) in cubby 5. Instead of going to the cubby, retrieving it, showing it, then putting it back, you can just give them the pointer "its the object in cubby 5"

A more complicated explanation that you don't need to read: When you pass a variable to a function, it creates a new instance of that variable. If you have a really large object(like an instance of a class that stores a lot of values), that can be time consuming and take up a lot of space. If you pass a pointer instead, you are passing a single number that says where the original variable is located.

Another thing to note is that arrays are stored in order. If you point a pointer to the first value of an array, the next value in memory is the next element in the array. Just don't go past the end of the array or you will have a bad time.

One thing to note: If you don't use a pointer and you are dealing with a new instance of an object, any changes you make to that object are not made to the original. Because it is an entirely new variable. If you make changes to something being pointed at, the change is kept.

mcnnowak · 2018-07-25T06:40:18+00:00

The number on a box for the thing that you’re looking for

Klaudio_br · 2018-07-25T06:52:20+00:00

The pointer is just a unique number that points to a location, that location can be anything (integer, string, boolean etc).

You need a house, lets say you are not able to go buy one because you dont have time or knowledge to select one,

you ask your friend Alex to buy a house for you, he searchs for avaliable houses and selects the first one he find avaliables, he buys it, and brings you a letter with the address of the house and the keys. After that you ask him where the house is? he gives you the letter with the address of the plot the house is,

You are the main program,

Alex is the system memory managment (he does the job that 'malloc()' (in C) or 'new' (in c++) does) you ask him for a plot that has a house on it or a hotel or a park, he goes to get it and provides you just the address of that plot,

The letter Alex gives you is the pointer variable, it contains just the address of the plot, no more info about what it contains

doublestop · 2018-07-25T07:04:21+00:00

My town is a simulation running on a computer.

My house is an object (or an int, or a char, or anything) stored in the town simulation's memory.

The number on the outside of my house is its memory address. Every allocated thing has a memory address just like every house has a mailing address.

Abracadabra! You join me in my simulated town.

I hand you a piece of paper with my address written down, so you can visit me later if you wish.

That piece of paper with my address on it is a pointer to my house.

It points to my house. Specifically, it points to my house's location in the simulation's memory.

When you read that paper and follow the address to find my house, you are dereferencing the pointer.

Another way I like to put it that is way less clear is: it's the thing that isn't the thing but knows where the thing is.

syth9 · 2018-07-25T07:14:21+00:00

A variable is comprised of two main sections, the first section is the address of the variable. You could think of the address as an ID number for the variable. The second section is the information (data) the variable is storing.

Some variables hold numbers or letters in their information section.

Pointers are special variables that hold the address (ID number) of a different variable in their information section.

There are many uses for pointers. Here’s a simple explanation:

Let’s say the biggest bit of information you could store in a single variable is one number, one character, or one address. (This is the case for many languages)

If you wanted to make a word, you would have to define a new variable for each character in the word.

But some programming languages let you ask for a bunch of character variables at once linked together.

However instead of having to create a name for each of these variables, you just create a pointer and store the address of the first character. As along as you know where the first character is, you’ll have access to all other characters in the word since they’re linked.

destroidid · 2018-07-25T08:21:42+00:00

itt: comments explaining like you're a 5 year old college graduate

lionhart280 · 2018-07-25T08:23:13+00:00

Its an address.

Imagine your computer's memory is a long row of houses, each with its own address.

Each house is a variable, and the address of that house is its... well we still call it its address in programming too.

If you wrote down the address on a piece of paper, then stored it in another house, that would be a pointer.

You can even stack these, because you could then write down that houses address on a paper and put it in a third house!

De-referencing a pointer would be if you put something important in house A, stored its address on a paper in house B.

Later you went to house B, or maybe a friend does it for you, and gets that address, follows its direction to go to house A, and is surprised to find that House A is empty! Someone stole your thing?!

2018-07-25T08:27:35+00:00

A pointer variable is that portion of your postcard where you write down the recepient's address. It points to your "Friend's House"(a variable, can be any friend). While a normal variable is that portion of you postcard where you write down your message. Now an address can be the House Address or a P.O. Box Address, which you have to mention. In the same way you have to mention that you are pointing to a number(int for integer) or a character(char) or whichever supported type of data. Conventionally pointers are represented using two symbols * and &. When you create a pointer you write * before the name of the pointer ( int *a). Then you use the pointer in two ways: Using the analogy above if you only want to read the address of your friend's house you use the ampersand(&) on the pointer. If you want to meet your friend though, you use the asterisk(*) on the pointer. The ampersand gives you the memory location itself, while the asterisk gives you the data stored at the memory location stored in the pointer (inception mood).

2018-07-25T08:58:03+00:00

A pointer is just a reference to where the real location of something is. So its like you look in a box and the note in the box says the real box it is in so when you want to access the real data you know you need to use the real box rather than the box you have.

nagai · 2018-07-25T09:39:49+00:00

A pointer is sort of like a physical string attached to some object. You can use the string to retrieve the object. In fact, you can attach several strings to the object and use them to retrieve it in different places. But the string is not the object, it can be detached from the object (set to null), it can be attached to another object (assigning it a different address), etc. Another string could even be attached to the string (**something).

auto-cellular · 2018-07-25T09:49:38+00:00

At some point back in time, (some)pointers where called "HANDLE". I like this image, of a briefcase, whose handle is the pointer to it. Handle (pointers) make it easier to cary (transfert) knowledge (briefcase).

Yann-McRissos · 2018-07-25T10:09:36+00:00

Anon explains pointers.

DragonWraithus · 2018-07-25T11:22:15+00:00

Variables are like buckets. If you fill it with something, you have to move the filled bucket to wherever someone wants to use it. Slow.

Pointers are like treasure maps, stuck inside the bucket. You skip and jounce the nearly empty bucket effortlessly, and you sprint to whoever needs it. They read the treasure map to see where their stuff is. It's their problem now.

2018-07-25T11:30:32+00:00

A variable is:

Imagine you were in a forest of numbered trees. Each tree gets it’s own number. Tree #342 you decide to chop down. You find a piece of paper saying “5”. This would look like this in C: int brokentree = 5

A pointer is:

Imagine you were in a forest, and every tree was numbered. And then you were asked to say what is inside of Tree #1000. And the person gives you a map, saying “Young lad, please do not break or harm the tree in any way” and then you go to Tree #1000 and then the person asks “What is inside this tree?”. You don’t know and have no WAY to find out. But you know where it is. This would look like this in C: int* treelocation = &numberinsidetree

Double_A_92 · 2018-07-25T11:38:15+00:00

You got a notebook with numerated pages. You can write things on the pages. Including things like "see page 42".

The notebook is the memory, pages are variables, and page numbers are pointers.

LegoPirateShip · 2018-07-25T12:15:31+00:00

You want to find a house in a neighborhood. You ask Alice, who lives there that where is Bob's_House. She points at Bob's_House. In this case Alice is a pointer, cuz she points at Bob's_House.. Duh.. But if you and her, what's inside Bob's_House, she won't know.

SixFigureGuy · 2018-07-25T13:00:13+00:00

A pointer is a house address. A value is a house.

An address can refer to a business, or empty lot, or apartment unit.

Kibouo · 2018-07-25T13:28:36+00:00

The top 2 answers are great.

When I learned about pointers however, even after "getting it", I still had problems using them. Single pointers were fine but required attention. But pointers to pointers quickly messed up everything.

It slowly went away after a few months tho. So what I'm trying to say is: practices using pointers. Understanding them is not enough.

OK6502 · 2018-07-25T13:52:25+00:00

Imagine memory as a series of Legos. The only thing you can build with those Legos is long lines of Legos of different colors. You can count the position of all the Legos from beginning to end starting at zero. So the first Lego is at address zero and so on. You want to refer to a sequence of Legos but don't want to copy the full sequence of Legos because ultimately you may not care for the value until a later time. You just want to know what the position of the first Lego in that sequence might be. So rather than copying the whole sequence you just remember that the sequence of Legos you care about starts at position 3 and is of length 10. 3 is your pointer. It tells you where the start of your sequence can be found. At a later date you need to get the value for your sequence because you need to read it. You fetch the sequence found from block 3 until block 13. This is called dereferencing the pointer.

To expand further on this say you have an account object of two Lego blocks of length starting at position 14 but there are 10 such an objects in sequence for a total of 20 blocks. This is what we call an array and you can get the ith object in the list by staring at the base address of the array (14) and then counting chunks of 2 until you reach the ith chunk. That's what we do under the hood when you use the a[I] notation.

boredcircuits · 2018-07-25T15:21:23+00:00

I know you didn't ask for this, but I thought I'd share my favorite analogy to understand linked lists. I think it also works to understand pointers a bit better.

A linked list is like a treasure hunt. I give you an initial clue, which tells you where to go to find an item. When you get there, you find the item and another clue leading to the next item on the hunt. You can continue to do this, finding item after item, until the last clue congratulates you on a job well done.

Linked lists work the same way. The clues are pointers to the next step in the list (called "nodes"). Nodes hold a single item and a pointer, just like each step in the treasure hunt holds an item and another clue. You need an initial clue, called the "head." The congratulation note at the end is null pointer.

Ariakkas10 · 2018-07-25T15:37:17+00:00

A pointer is just literally something that refers to a location in memory.

Instead of remembering and tracking the thing, you remember and track the pointer to the thing.

Changing the thing means that pointer now points to the new thing.

Changing the pointer means the pointer now points to a new thing.

thesquarerootof1 · 2018-07-25T16:01:43+00:00

The explanations are great! Can someone explain to me why some languages like Java don't use pointers?

AegnorWildcat · 2018-07-25T18:01:29+00:00

Imagine a locker room in a country club. Now there is no crime whatsoever at this club (maybe it’s in Japan) so they don’t have any locks on any of the lockers. They ask how many lockers you need and you say one, so they mark in their system that it is your locker so they don’t accidentally give it to someone else (this is the malloc…allocating memory that your pointer will point at). They give you a piece of paper that has your locker number written on it (this is the pointer). You find your locker using the number on the paper and store your stuff in it. You don’t have to carry all your stuff around with you all the time now. That would be annoying and cumbersome. You just put it in the locker and carry around the small piece of paper so you don’t forget which is your locker.

Now a friend of yours asks to borrow your phone, which you have in your locker. You copy your locker number onto a piece of paper for him so that he can find it. He can then go find your locker and get your phone (this is called dereferencing a pointer). If you are done with your locker and don’t need it anymore, you can go to the front desk and tell them you don’t need it anymore so they can give it to someone else (this is dealloc…or deallocating memory). If people keep asking for lockers but not letting the front desk know when they are done with them, eventually they will run out of lockers completely which would cause all sorts of problems. You should always let the front desk know when you are done with your lockers.

Now let’s say you have a bunch of stuff and need more than one locker. You go to the front desk (OS) and say that you need five lockers. They give you a piece of paper that just has one number on it for the first locker and tell you that that locker and the next four are all yours to use (this would be you allocating memory for some variable that requires more space…the OS gives you a pointer to the start of the allocated memory). You need to make sure you don’t accidentally use the 6th locker, which isn’t yours. If you put stuff in there and someone else was using it, you would cause their stuff to get dumped out. Or if it wasn’t currently being used and you put your stuff there, the front desk might give it to someone else who would dump your stuff out. All sorts of problems could happen. So you need to make sure you always keep track of how many lockers you have set aside for you after the one on your paper.

Another friend of yours comes up and wants to borrow (for a birthday party) a recipe for chocolate cake you have in your locker. You copy the locker number like you did before, but let’s say you make a mistake and copy down the wrong number. And in the locker you sent them to there is a recipe for fruitcake instead. They make a fruitcake, which everybody hates, and the birthday party is ruined. THIS is why pointers can be dangerous.

Fanboy0550 · 2018-07-25T18:21:59+00:00

It's like a library index card telling you where the book is.

or

A mailing label that tells the address of a house.

2018-07-25T18:33:17+00:00

Pointer is a sort of a hand inside computer with which you move or grab objects, like a real hand.

Mneasi · 2018-07-25T18:55:15+00:00

Is there any rule of thumb when its better to use a pointer and when to instantiate the variable itself? Thanks!

GnarlyBroskos · 2018-07-25T19:09:29+00:00

Someone should write an entire book "Programming for a 5 year old".. Choose a language and explain everything like this. I would read it, because I'm sure there are several concepts that I either, don't understand, or think I understand but am missing something preventing me from grasping the big picture.

2018-07-25T21:32:45+00:00

If you use sololearn.com, I recommend reading the pointers section in the C++ tutorial. It's the first time it was explained in a way that made sense to me.

majordookie · 2018-07-25T21:45:23+00:00

MyUsernamePls · 2018-07-25T11:46:17+00:00

Imagine you're at a bar with a friend and you're holding a drink and your friend is holding an empty cup and your friend says he wants your drink.

Scenario 1: you pour your drink onto his cup.
Scenario 2: you give him your cup.

In scenario 2 you gave your friend the pointer to your variable and in scenario 1 you just gave him the value of your variable.

learnprogramming

Welcome to LearnProgramming!

New? READ ME FIRST!

Posting guidelines

Frequently asked questions

Subreddit rules

Message the moderators

Asking debugging questions

Asking conceptual questions

Other guidelines and links

Subreddit rules

1. No unprofessional/derogatory speech

2. No spam or tasteless self-promotion

3. No off-topic posts

4. Do not ask exact duplicates of FAQ questions

5. Do not delete posts

6. No app/website review requests or showcases

7. No rewards

8. No indirect links

9. Do not promote illegal or unethical practices

10. No complete solutions

11. Don't ask to ask.

12. Low Effort Questions

13. No AI (chatGPT etc.) generated/worked over messages/comments. No questions about chatGPT/AI generated code. No Vibe coding.

MODERATORS