you aren't real programmer if you don't fully understand pointers.

>>105870428 (OP)
>you aren't real programmer
you are not a real programmer cnile. Rust has superseded your toy language.

>>105870466
Competent rust programmers understand pointers and you don't.

>>105870428 (OP)
Ok but they're not hard to understand. It's just that C made it complicated.

>>105870428 (OP)
>POINTer POINTS to memory address
that's it really.

>>105870466
fpbp, op utterly fucking destroyed.

>>105870580
Bot post. Rust has pointers.

>>105870685
which you aren't really supposed to use in normal cases since references > pointers.
kys faggot

pointers are literally 1st year CS undergrad shit
how could someone learn to program and not understand pointers?

>>105870466
>Rust has superseded your toy language
this
plus trans women are real women and being attracted to minors is valid and completely sane
deal with it

>>105871000
you can program without understanding anything at all

>>105871000
because most techlet "coders" have only ever used javascript or python so the simple concept of "thingie points to place in memory" is foreign for them.

>>105870428 (OP)
Whoever wrote your slide doesn't really understand pointers either. Pointers to pointer aren't really about the value of 'var', they're about the value of 'ptr', and the ability to point 'ptr' to something new. This is a bad example because it's lazy.

>>105870884
Unless you do FFI, allocators, containers or any sort of low level stuff. You know, things that systems programming is good at. It's all pointers then.
Also references in Rust are just pointers with lifetime semantics. They aren't a special thing like in C++.

>>105870493
C did not even make it complicated. The only "difficult" parts are a) the meme that pointers are confusing causing new programmers to not even try to understand them and b) people who do not understand how memory accesses work. (a) filters retards who have not yet learned how to adopt a learning mindset. (b) filters retards who never even learned how to do algebra.

Sometimes I feel bad for not being a real programmer. But there are so many things I regret not being. Like a mozart genius musician, a brain surgeon, a millionaire..

My life is pretty disappointing

>>105870428 (OP)
>

>>105871188
There are people out there who consider themselves programmers who do not understand how CPUs work and how memory addressing works. This sometimes blows my mind.

>>105870428 (OP)
pass by value
pass by ref
zzzzzz

>>105871268
Pointers are passed by value in C. C does not have reference semantics. Pointers allow to implement referential access.

>>105871229
I have no idea how MMU works but it never was a problem to me, no matter how high or low level stuff I was working on.

>>105870428 (OP)
I understand them
I haven't had the need for this knowledge in over 7 years working for a few different companies
>You're not a real programmer
Bet I make more money and deliver more code than you

>>105870428 (OP)
Pointers are unsafe cnile slop
Rust deprecated C/C++

>>105871229
>>105871312
For the most part building a usable mental model for the CPU is pretty simple. You do not need to know the details. A big part of the problem is people who equate "contemporary CPUs are too complex to understand completely" with "it is impossible to build a useful mental model of how computers are organized and function." Programming education in general makes this even harder with the insistence on abstracting programs from hardware (e.g. when in university I had many CS teachers who would say the hardware is irrelevant and not to bother trying to understand how an algorithm is computed, which made sense in the context of the course, but was not generally good advice.) Languages like JavaScript and Python also have more difficult semantics to really understand and are generally explained extremely poorly, and as those are often the first languages new programmers see, well, a pattern is set and continues throughout their lives.

>>105870428 (OP)
You need to understand pointers to be a real programmer, but C syntax has nothing to do with pointers. C shills constantly lie and act like pointers are some kind of C invention.

>>105871000
>how could someone learn to program and not understand pointers?
Because they are C programmers. C makes it impossible to understand pointers because they're constantly confusing them with arrays and bewildered by the C syntax. An array is not a pointer. A string is not a pointer. The character * has nothing to do with pointers.

>>105871118
>because most techlet "coders" have only ever used javascript or python so the simple concept of "thingie points to place in memory" is foreign for them.
JavaScript and Python use that concept more than C does because they're based on Lisp. At the time Lisp was made, pointers were considered a domain-specific feature for list processing. Mainstream languages didn't have pointers.

>>105871229
>>105871379
CPUs work however the designer makes them work. A CPU doesn't have to resemble the C abstract machine or PDP-11 at all. C programmers don't understand that.

>>105871559
>A CPU doesn't have to resemble the C abstract machine or PDP-11 at all. C programmers don't understand that.
All CPUs in commercial use in current year do.

>>105871581
>All CPUs in commercial use in current year do.
Normal science
>based on how the universe works
Computer """science"""
>based on "commercial use in current year"

>>105871559
Correct. Processors are implemented however they are implemented. The point is that building an understanding of "oh hey, this is how I can think about a memory and this is how I can map my operations onto it and this is how I can think about how the machine uses the memory" does not require to understand precisely how the machine is organized, or what specific instructions are used to actuate the MMU or how the OS uses the MMU to provide address spaces or how different clock regions are organized or what specific instructions will cause a bus stall. A basic understanding of how the machine can implement the abstract concepts goes a long way regardless of what language you are writing in.
>>105871581
This is not necessarily the case in embedded. While ARM MCUs dominate, especially for new projects, weird 8 bit MCUs like PIC16F are still in use and people still write code for them. These MCUs typically have instruction sets that do not map all that well to C abstract machine.

>>105871620
Instead of just saying
>you're right, of course, but there is nothing *requiring* them to do so
you just devolve into your usual tranny rage. You seem like you used to be smart, it's sad what those chemicals did to your brain.

>>105871662
>do not map all that well to C abstract machine.
You're not totally wrong, but it's worth noting (picrel)
>Since the most widely used high-level programming language for PIC microcontrollers is C, this document will focus on C programming. To ensure compatibility with most PIC C compilers, the code examples in this document are written using ANSI C coding standard.
It's really the only language used, unless you consider assembly to be a language. I think C is the only language even available for these chips.

So although you're "right", I don't consider you to really be all that right.

>>105871662
>map all that well to C abstract machine
the only abstractions C has are function calls and loops, they map to the instruction set in the same way you'd write them in assembly

>>105871771
>C abstract machine
He's talking about the C language ISO/IEC standard's usage of the term "abstract machine".

>>105870428 (OP)
I don't need to, ASM doesn't have pointers

>>105871829
You sound like one of those guys who is
>it's all just atoms and molecules bro
then uses this to justify fucking a dude's asshole

>>105871893
Everything is easier in ASM, the abstraction is minimal. The processor does exactly what you tell it to and not a command more.

Nothing is obfuscated by some obtuse bloatware library OOP users like so much.

>>105871962
For instance pointers, pointers are a pain because their behavior is complicated in how the compiler handles it, meanwhile functions in ASM take variables either via registers, memory, stog (fancy memory structure) or definition behind BL (fancy memory again).

>>105871761
Yes. I will admit the last time I wrote for PIC was 20 years ago in university and perhaps the state of the art has advanced since then; however, we used a mix of C (the C compiler we used was absolute garbage) and ASM. The C was largely computation and glue. The fact that C is the most widely used "high level" language for these MCUs is more due to the fact that "everyone" knows C and there is a vast respository of knowledge on how to write C. Rolling your own language that better maps to the hardware, especially for machines as small as this, just is not feasible or smart.
>>105871771
See >>105871799 and consider, too, that C supports a number of "abstractions" such as types, pointers, structs, unary and binary operations (e.g. &&, !, +, ?:, etc), switch/case/if/else, variables, variable scoping. The list goes on. All of these are concepts abstracted from whatever machine a given compilation of a C program targets, even if many of these abstractions can map cleanly.

>>105872031
No shitty ass "this is a pointer to this adress meanwhile this a a variable, this a pointer pointer that you need to derefrence to pass to..." ah shit, you pass variables to function either via registers or memory

why do people act like this is some great filter in the programming world lol

>>105871663
>>you're right, of course
But that's not right at all. They don't actually resemble PDP-11s. The PDP-11 is a specific model of computer

>you just devolve into your usual tranny rage. You seem like you used to be smart, it's sad what those chemicals did to your brain.
That's all projection like you C shills always do. There was no rage at all in that post, just facts that are uncomfortable for you. The rage you feel is your own. Computer """science""" is based too much on what is popular instead of what we have discovered and know how to do like real sciences. It wasn't always like that. Designing hardware, programming languages, and operating systems used to be a big part of computer science. Now it's how to use C or how to use Google.

>>105870466
t. visajeet

>>105871771
>the only abstractions C has are function calls and loops, they map to the instruction set in the same way you'd write them in assembly
And operators, types, structs, variables, expressions, assignments, etc. All of those are abstractions. In C, they're leakier and weaker than most languages, but they're still abstractions, except C programmers are not aware of that.

>>105872073
You're the only "person" talking about PDP-11s, troon. And the pure seethe from your words wafts from the screen. I don't think you even know why you seethe so hard. Maybe you're an experimental SeetheAI for next-next-generation 4chan warfare.

>>105872097
>>105872073
You guys aren't understanding this. The "C abstract machine" is what the ISO/IEC standard targets, and "implementers" map this abstract machine to real machines, with variable "quality of implementation" which loosely translates to efficiency/execution speed/code size or whatever attribute of code generation required by users of said implementation.

You guys keep listing C abstractions, that was never the point.

>>105870428 (OP)
Do you fully understand monads.

>>105872156
oblig

>>105871379
Yea, I know how CPUs work, I designed simple ones in GHDL/VHDL and some games. I just never had to do anything related to modern MMU.

can anyone explain the "C abstract machine"?

>>105872149
>>the only abstractions C has are function calls and loops,
>You guys keep listing C abstractions, that was never the point.
Pick one, Ctranny.

>>105871159
sounds like bad code smell, do better and you won't have to use pointers cnile :^)

>>105872530
academic nonsense

You aren't a real programmer if you don't understand virtual memory
#include <iostream>

int main()
{
int val = 0;
*((int*)(((int64_t)&val) | (1 << 53))) = 12345;
std::cout << val;
}

>>105872168
Thank you for posting the muse. Never not funny.

>>105873691
C/C++ brain damage has nothing to do with virtual memory.

>>105873720
Two different addresses lead to the same location. That's virtual memory.

>>105873691
>int64_t
>not uintptr_t
Nocoder detected

>>105873761
>posts code(good or bad)
>nocoder
I bet you have a ``diagnosis''. Am I correct?

>>105873735
Addresses wrapping around have nothing to do with virtual memory. Computers with no virtual memory can have that, and it's sometimes used for memory tagging in languages like Lisp because it means they don't have to remove the tag because the hardware just ignores it. Virtual memory is when you can use space on a secondary storage device (like a disk or flash drive) as if it was memory. The computer handles moving data between the RAM and the device. Mezzano uses virtual memory the right way because all the valid data in the whole partition has a memory address. Instead of files, you just use paging.

>>105870466

>>105870428 (OP)
They literally store a variable with a * as decorator to retrieve it, not different from doing arr[2] which is in fact the same as *(arr+2). You're most likely a newfag nigger in programming

>>105873815
Anyone can generate some code nowadays. But not everyone can understand what is wrong with it.

>>105873861
>They literally store a variable with a * as decorator to retrieve it, not different from doing arr[2] which is in fact the same as *(arr+2).
C enshittified your brain. Pointers are not arrays. Pointers have nothing to do with *.

>>105874697
guess you felt attacked as the newbie programmer retard you are, the difference doesn't fucking matter. you can tell some fag is coming straight out of college or in college or underage by these retarded discussions

>>105873846
>Virtual memory is when you can use space on a secondary storage device (like a disk or flash drive) as if it was memory
No, you're using virtual memory even when you have no swap.
https://youtu.be/dFIqNZ8VbRY

>>105873872
>Anyone can generate some code nowadays.
>But not everyone can understand what is wrong with it.
No, if anyone can generate code, then anyone can understand what is wrong it. I am guessing low functioning aspie with a bit of retardation and adhd.

>>105875506
>No, if anyone can generate code, then anyone can understand what is wrong it.
Lol. Have you even heard of LLMs?

>>105872530
A flimsy justification for undefined behavior.
>Your operation's result is not defined in our abstract machine, therefore we can delete your code.

>>105870428 (OP)
This is the worst image that i have ever seen which tries to explain ptrs

>>105871188
The concept itself is simple but C made the syntax horrible and unsafe. The asterisks back and front that can be double and this shit & I forgot the name aren't exactly easy to remember for newbies. At the time it was done that way because computers weren't fast do the syntax had to be closer to machine code. It's the same reason we use ; instead of nothing and why some compilers force you to have a newline at the end, because it's easier for the computer.

>>105872168

>>105876258
im sorry you were filtered by C.
take another code camp, you'll get there.

>>105873691
Use case?

>>105876258
>At the time it was done that way because computers weren't fast do the syntax had to be closer to machine code.
No it's not. C syntax has nothing to do with machine code. C is dumbing you down even now.
>It's the same reason we use ; instead of nothing and why some compilers force you to have a newline at the end, because it's easier for the computer.
That's actually a feature. FORTRAN and BASIC had one statement per line with a continuation character. ALGOL had ; because it lets you have multiple statements on one line and statements that span multiple lines more easily.

>>105871000
exactly like why zoomers don't know what a directory is

>>105870466
>I win because I said cnile

>>105877610
this is what happens to your brain when you cut your dick off

>>105870466
rust haven't superseded shit, delusional tranny

I wish I could be smug and say "who doesn't understand pointers?" but some anons make me wonder..

>>105870493
>>105871188
>>105876258
>>105876529
The thing that C makes nonintuitive is the storage of the type in the pointer itself, e.g. the fat that you can have an int*, char*, and all these different types of pointers, rather than just having one pointer type.
It would be better if every pointer acted the way a void* does. If you only specified type when dereferencing, it would make it much clearer that a pointer is just an address, which might point to meaningful data.
>b-but that's unsafe
Pointers are inherently unsafe, there's a way to have strict type safety, it's called not using pointers. The only time you should ever be passing something by reference instead of value is when it's a data structure, in which case the behavior needs to be encapsulated in syntax that doesn't allow manually dereferencing.
The different types of pointers are not only needlessly complicated but an illusion of safety. You have no idea if it's safe to cast something at the address to that specific type. Basically any time you get the pointer of a variable (like with &) you should be bypassing type checking entirely and the language should support it as just raw dogging memory.

>>105879387
>pointers are unsafe
go away

>>105879434
They are, and having types attached to them like long long dong* doesn't make them safe

>>105876993
> Does not know how compiler history
It's designed that way to make compiler's job easier.

> That's actually a feature.
No it's not. It's also because it was easier for compilers to know when a statement ended.

>>105879387
> Have no type in pointer would make it more intuitive
That would be a solution yes.

> Pointers are inherently unsafe.
They are but they could have some sort of protection when developers fuck up. Today that would be possible.

>>105870428 (OP)
I never understood what people find hard about them. this should be an obvious concept for anyone with >85IQ.

>>105879387
>, and all these different types of pointers, rather than just having one pointer type.
because having one pointer type to fit all would be insane bloat. fuck off, tranny.

>>105879595
it filters people new to programming that don't know shit and can't read manuals. if you had programmed in assembly languages before you can instantly understand the idea behind pointers and how they're used. baby level knowledge.

>>105879595
Some people are simply incapable of understanding fundamental programming concepts.
I couldn't find the source but I remember there being an old study or publiction or something that showed that in any given programming class, there will almost always be a subset of students who won't ever be able to form the mental model required for understanding what a basic snippet of code does and will struggle even with things like reassigning variables and intuit their values between each statement.
Explaining concepts like pointers or recursion to those kinds of people would be impossible.

>>105870428 (OP)
First time I read about them I had a hard time understanding them because there was no mention of WHY you wanted to use them. It seemed really pointless (heh) to me (I was quite young at the time)
So I blame the learning materials

>>105880244
this is a good point (heh). I guess rationale for their existence wouldn't be obvious to a beginner.

>>105879611
>bloat is when there's fewer features

>>105880539
> not coping
sad