In programming you have to practice mental skills. That is, abstract problem solving, logic, bigger-picture-how-things-fit-together. There's a reason many beginners struggle with concepts like pointers or recursion/recursive data types. These things become second nature with practice, just like the physical skills do, but to a beginner who has not practiced such things, they're equally difficult.
Introducing them to the end user who just wants a way to track project status is a great way to bar them from actively participating in developing their own solutions. Forcing them to be beholden to the IT department, rather than empowering them to accomplish their goals.
You know it's not true. Pointers, references, whatever you call them. They exist for a reason.
We're talking about accessibility for getting started. Pointers and recursion are good ways to scare people away. They were all my highschool CS teacher cared about... guess who avoided CS for a few years as a result until figuring out ways to use other languages to solve specific problems in non-CS courses several years into college?
Why do you never hear these types of complaints when people say it takes 10000hr to master the piano? People never suggest taking shortcuts and people accept and respect the path of becoming a master. But when it concerns programming, everyone immediately jumps to "how can we make this as dumb as possible?"
Guys. Shit takes time and effort. The freshmen will be fine.
Ah yes, those stupid noobs, fuck them all. The objective is not to "dumb down" but to permit the expression of intent by people to achieve their own ends, without the need for intervention by members of the programming guild.
Not everyone needs to master programming, they need to achieve a goal. Just as someone can build a table without ever becoming a master carpenter (it's a saw, sandpaper, and a drill and screws or hammer and nails, done), many people have problems that could be solved with programming if only the manner of interfacing and directing a computer were not unnecessarily arcane.
> Guys. Shit takes time and effort. The freshmen will be fine.
Guy, it's not about the freshmen. It's about people who need to get shit done. It'll be fine if professional programmers aren't the only ones who can achieve their ends with programming tools.
"Self" learning is a pipe dream. You are always being guided. Be it statically and indirectly by the tutorial writer, the comments of the youtube tutorial, or some discord community helping you out. This is not a bad thing. Stop acting like I'm advocating for some evil elite.
> Not everyone needs to master programming, they need to achieve a goal
Great! For them exists python.
> if only the manner of interfacing and directing a computer were not unnecessarily arcane.
I agree that it would be a net win if the likes of linux tutorials stopped using vim. Once we look past that we can see there are plenty of ides out there today that perform the function of the article's subject. Underlining faulty expressions, suggestions on how to fix it, a nice debug output at the bottom.
> It's about people who need to get shit done
You need a good baseline. You just do. Plenty of people won't do their own plumbing either. It would take a bit of time to learn the basics to fix your sink (python script), but to become someone who can design the pipage in a building ("business software")? That just takes time and experience. No way around it.
Great! For them exists python.
And there I was hoping that I wasn't unfairly stereotyping you.
If you want to play classical piano that's true. If you want to play piano in a band there are lots of tricks to make improvisation and harmonization easier. Every music store sells 'fake books', which document the lyrics and melody of popular songs with simplified harmony using basic chords so you can knock out songs in a bar or at an event that will be easily recognized by casual audience. If you use electronic keyboards they either have 'auto accompaniment' or sequencing features built-in so you can vamp in one key or just play chords and have an arpeggiator pump out a riff, which tools have given rise to new musical styles of their own.
Likewise bass players often use shapes to navigate the fretboard just as guitar players may use capos or slides to make chording easier. Lots of great musicians get by with little music theory or even literacy; Dave Brubeck was nearly thrown out of music school when they found out he couldn't read music and had just been copying his instructors or recordings by ear, and he had to sign an agreement that he would never teach music in order to graduate.
Theory is important, but it's not the whole story by any means. There are lots of excellent pianists who are not skilled at improvisation and have never composed anything.
Bringing it back to computing, this is Hacker News, not Engineer News or Computer Scientist News. Tinkering and bricolage are a key part of hacking, which is often about tactical problem solving rather than industrial reliability or pure craftsmanship. What I'm hearing from you is an emphasis on process rather than result, which is good for developing one kind of skill but closes the door to many other possibility. It reminds me of the derision for 'toy languages' like Python when they first appeared - and yet the latter is now the most widely used programming language of all, because it's accessible.
That doesn't make knowledge of C any less valuable (or aesthetically satisfying) but it does mean that people can get tasks done without necessarily needing a low level understanding of types, memory management and so on. I like pointers and the beautiful simplicity of the structures you can build with them, and I like the feeling of omniscience I get reversing something in a debugger and reading assembler. But I also like writing craptastic working prototypes of things in an hour and using them for weeks or months before rebuilding them into something reliable that I can leave running unattended.
I'm strongly in favor of programming tools that make things fun, accessible, and results-oriented rather than forcing everyone through a period of misery in order to gain elite status. Yes, this will increase the number of half-ass programmers and half-ass software projects, but also equip a much wider number of people with some useful skills that can be refined to find their own level, just the same as people with some DIY skills can be handy and are in a better position to learn advanced skills than people who have never worked with their hands at all.
I don't understand how that's offensive or so counter-intuitive.
The piano is a perfect example of something accessible: you push a key, you get a note. You push a different one, you get a different one. That doesn't prevent there from being a lot of complexity and practice needed for mastering it.
Your plumbing example from elsewhere in the discussion is also a perfect example:
> It would take a bit of time to learn the basics to fix your sink (python script), but to become someone who can design the pipage in a building ("business software")? That just takes time and experience.
Python exists. It makes "fixing the sink" task easier than C. C makes it easier than assembly. Why on earth would suggesting that we could peel off even more of the rough edges for beginners be insane? That's literally an example of how we've done it in the past. Obviously Python exists. Obviously it doesn't need pointer knowledge to use. Just like we were saying.
EDIT: Maybe the distillation of where I think you're not following the original article and argument here is that "the things that make programming hard to get started with" are not the same as "the things that make programming hard to master."
No, I don't.
> Pointers, references, whatever you call them.
References are not pointers, and I stand by what I said. Pointers are not needed by most people writing software outside of very specific domains.
References are a related but distinct concept. I can "hold a reference" to something without ever being able to read what its memory address is or change what memory address that reference points to. The power to do that is unnecessary for most programs that are written.
> They exist for a reason.
Did I ever say otherwise?
EDIT: Expanding on the notion of "need". A programmer using a C library "needs" pointers because the C library almost certainly makes use of them. The user may or may not need to use pointers themselves to interact with the library (that is, it may offer an interface based on values and not pointers). A programmer on any OS I can think of will be making use of pointers through similar levels of indirection. As an Erlang hobbyist, the implementation almost certainly uses pointers internally, but as an Erlang programmer I wouldn't use them directly. In order to write a program in Erlang, I never need a pointer, though I may make use of some kind of reference (process IDs are a kind of references, but they are not pointers).
Ok. So don't use that power then. Or use references instead, which are conceptually the same thing.
> Did I ever say otherwise?
You quite clearly stated their purpose was very niche. I think you took my statement a bit to literally, as what I meant to convey was: no, they are not niche.
Edit: after reading your edit, I would like to remind you we were discussing the needs of learning the concept of pointers. While what you mention may not be literal C pointers, that is besides the point (haha) because they (methods of indirection) are conceptually equal.
In the same sense that a donut is topologically the same as a coffee mug, sure.
> You quite clearly stated their purpose was very niche.
I did not. I said they weren't needed outside of specific domains, which is not the same as "niche".
> we were discussing the needs of learning the concept of pointers
Per my original comment, no, we were not. I wrote of needing pointers. I said nothing about the needs of learning the concept of pointers.
My comment was, and I stand by this, that pointers are a fantastic example of accidental complexity. They are present in many programming languages, and are a thing people have to use as a consequence but which are not themselves necessary for the problems that many people intend or need to solve. References, which are not the same as pointers except again in the sense of donut = coffee mug, are a more general concept that has broader utility than pointers without the added complexity that pointers bring to the table (though depending on the manner of the references they may bring in their own, see both Python and Java and the unintentionally altered collection values).
In which ways are references of broader utility? And what is so complex about pointers? The fact that it doesn't hide behind language magic? Well, that you can just ignore: I don't _need_ to see or edit the address it holds.
The physical address in the linear space [1] isn't just the obvious option, it's the only option. [2] It's a short step from there to indirect addressing via a linear lookup table, and/or simple address arithmetic to find items stored sequentially.
You can only avoid this by adding layers of abstraction which hide these mechanisms.
But you can only do that after the mechanisms are in place. Otherwise your "reference" is just an unimplementable idea with no meaning.
[1] Ignoring hardware paging, because that's usually invisible.
[2] Ignoring hypothetical magic associative O(1) key-value store hardware with the same speed as semiconductor RAM - which could be built at ludicrous expense, but would cause complexity issues of its own.
https://www.tutorialspoint.com/d_programming/d_programming_p...
The toy virtual machine and language I built in D uses function pointers heavily to implement the machine's opcodes. They made it incredibly simple to program the 'CPU' of the virtual machine. The opcode functions are setup as an array of function pointers.
Whenever a byte that represents an opcode is read, it simply calls the function being pointed to at the corresponding index in the array. It allows for additional opcodes to be easily added without hassle or breaking things. Every other way I tried without pointers was convoluted and didn't work as expected. Using an array of function pointers just works.
These skills are not unique to programming. It’s true that building sophisticated applications requires skills that need to be developed over time. But there are many many useful programs short of that that can be written with a beginner’s limited knowledge. We see already with python widespread use by non computer scientists in certain fields. I think going forward this will become more and more common across more fields and beyond academia.