#basic difference between c++ and java programming language

[no-sharks-on-the-sun]

@tanadrin i think people make Rust out to be more limited than it actually is. i mean, it's not a frontend or prototyping language, which means there's a bunch of stuff (gamedev, classically) which is a pretty bad idea to attempt with it. but i think most things you could use C, C++, Java, or Go for, you could use Rust for as well.

As for why I like it, I think it comes down to three things - Rust is explicit, Rust is robust, and Rust is ergonomic.

In terms of explicit, to start, Rust is strongly-typed, which is basically table stakes for a modern programming language. But Rust also clearly specifies whether things are pass-by-value or pass-by-reference (a distinction that is often obscured in other languages) AND whether an object is mutable or not, since Rust takes the rare step of being immutable by default.

So you incur some extra penalty for writing these things out, but the tradeoff is that you have a more granular mental model of your code (and other people's code is more readable).

In terms of robustness, Rust's big claim to fame is that the ownership system prevents multiple mutability, so whole classes of bugs are eliminated. But honestly, that's probably not even the big thing for me - I really love that there are no null pointers, just Option types, so instead of having to remember whether I need to check for nullity, I will simply know based on the type system if I need to handle a null case or not.

One interesting way to draw out what this means in practice is the difference between writing in Python and Rust - whenever I write something in Python, it runs, whereas every time I write something above a certain size in Rust, I have at least a couple of compiler errors. But once those errors are fixed, my incidence of bugs in my Rust code is noticeably lower than in my Python code.

And finally, Rust is just fun to use! Pattern matching is really satisfying, as is chaining together function calls. The ? operator is maybe the biggest ergonomics dunk I've seen by one language over another - Go and Rust have similar error-handling philosophies (eschewing explicit exceptions in favor of a hard deviation between recoverable errors and unrecoverable panics) but Go didn't build this into the language, so there are all these awful if err != nil checks lying around all the time, which in Rust is handled entirely by putting a ? after the function call.

In terms of downsides, I would say the main issues are:

Verbosity - the sword cuts both ways, you just don't get implicit conversions the same way you do in other languages. This is particularly painful for the different String and integer types, in my experience.

Learning curve - Rust isn't just creating new concepts that you have to deal with, it also stops using a bunch of (often leaky) abstractions that other languages use to make your life easier. If you haven't coded in another low-level language beforehand, the curve gets even steeper.

And I guess to add a minor nitpick - coming from Python, which has an absolutely cavernous standard library, Rust has a pretty small one, which leads to certain popular crates (most notoriously serde) having a "semi-standard" place in the community where everyone uses them but you still have to treat them like a normal dependency. I think this is bad.

[simerjeet]

Mastering Data Structures: A Comprehensive Course for Beginners

Data structures are one of the foundational concepts in computer science and software development. Mastering data structures is essential for anyone looking to pursue a career in programming, software engineering, or computer science. This article will explore the importance of a Data Structure Course, what it covers, and how it can help you excel in coding challenges and interviews.

1. What Is a Data Structure Course?

A Data Structure Course teaches students about the various ways data can be organized, stored, and manipulated efficiently. These structures are crucial for solving complex problems and optimizing the performance of applications. The course generally covers theoretical concepts along with practical applications using programming languages like C++, Java, or Python.

By the end of the course, students will gain proficiency in selecting the right data structure for different problem types, improving their problem-solving abilities.

2. Why Take a Data Structure Course?

Learning data structures is vital for both beginners and experienced developers. Here are some key reasons to enroll in a Data Structure Course:

a) Essential for Coding Interviews

Companies like Google, Amazon, and Facebook focus heavily on data structures in their coding interviews. A solid understanding of data structures is essential to pass these interviews successfully. Employers assess your problem-solving skills, and your knowledge of data structures can set you apart from other candidates.

b) Improves Problem-Solving Skills

With the right data structure knowledge, you can solve real-world problems more efficiently. A well-designed data structure leads to faster algorithms, which is critical when handling large datasets or working on performance-sensitive applications.

c) Boosts Programming Competency

A good grasp of data structures makes coding more intuitive. Whether you are developing an app, building a website, or working on software tools, understanding how to work with different data structures will help you write clean and efficient code.

3. Key Topics Covered in a Data Structure Course

A Data Structure Course typically spans a range of topics designed to teach students how to use and implement different structures. Below are some key topics you will encounter:

a) Arrays and Linked Lists

Arrays are one of the most basic data structures. A Data Structure Course will teach you how to use arrays for storing and accessing data in contiguous memory locations. Linked lists, on the other hand, involve nodes that hold data and pointers to the next node. Students will learn the differences, advantages, and disadvantages of both structures.

b) Stacks and Queues

Stacks and queues are fundamental data structures used to store and retrieve data in a specific order. A Data Structure Course will cover the LIFO (Last In, First Out) principle for stacks and FIFO (First In, First Out) for queues, explaining their use in various algorithms and applications like web browsers and task scheduling.

c) Trees and Graphs

Trees and graphs are hierarchical structures used in organizing data. A Data Structure Course teaches how trees, such as binary trees, binary search trees (BST), and AVL trees, are used in organizing hierarchical data. Graphs are important for representing relationships between entities, such as in social networks, and are used in algorithms like Dijkstra's and BFS/DFS.

d) Hashing

Hashing is a technique used to convert a given key into an index in an array. A Data Structure Course will cover hash tables, hash maps, and collision resolution techniques, which are crucial for fast data retrieval and manipulation.

e) Sorting and Searching Algorithms

Sorting and searching are essential operations for working with data. A Data Structure Course provides a detailed study of algorithms like quicksort, merge sort, and binary search. Understanding these algorithms and how they interact with data structures can help you optimize solutions to various problems.

4. Practical Benefits of Enrolling in a Data Structure Course

a) Hands-on Experience

A Data Structure Course typically includes plenty of coding exercises, allowing students to implement data structures and algorithms from scratch. This hands-on experience is invaluable when applying concepts to real-world problems.

b) Critical Thinking and Efficiency

Data structures are all about optimizing efficiency. By learning the most effective ways to store and manipulate data, students improve their critical thinking skills, which are essential in programming. Selecting the right data structure for a problem can drastically reduce time and space complexity.

c) Better Understanding of Memory Management

Understanding how data is stored and accessed in memory is crucial for writing efficient code. A Data Structure Course will help you gain insights into memory management, pointers, and references, which are important concepts, especially in languages like C and C++.

5. Best Programming Languages for Data Structure Courses

While many programming languages can be used to teach data structures, some are particularly well-suited due to their memory management capabilities and ease of implementation. Some popular programming languages used in Data Structure Courses include:

C++: Offers low-level memory management and is perfect for teaching data structures.

Java: Widely used for teaching object-oriented principles and offers a rich set of libraries for implementing data structures.

Python: Known for its simplicity and ease of use, Python is great for beginners, though it may not offer the same level of control over memory as C++.

6. How to Choose the Right Data Structure Course?

Selecting the right Data Structure Course depends on several factors such as your learning goals, background, and preferred learning style. Consider the following when choosing:

a) Course Content and Curriculum

Make sure the course covers the topics you are interested in and aligns with your learning objectives. A comprehensive Data Structure Course should provide a balance between theory and practical coding exercises.

b) Instructor Expertise

Look for courses taught by experienced instructors who have a solid background in computer science and software development.

c) Course Reviews and Ratings

Reviews and ratings from other students can provide valuable insights into the course’s quality and how well it prepares you for real-world applications.

7. Conclusion: Unlock Your Coding Potential with a Data Structure Course

In conclusion, a Data Structure Course is an essential investment for anyone serious about pursuing a career in software development or computer science. It equips you with the tools and skills to optimize your code, solve problems more efficiently, and excel in technical interviews. Whether you're a beginner or looking to strengthen your existing knowledge, a well-structured course can help you unlock your full coding potential.

By mastering data structures, you are not only preparing for interviews but also becoming a better programmer who can tackle complex challenges with ease.

[watchmorecinema]

Normally I just post about movies but I'm a software engineer by trade so I've got opinions on programming too.

Apparently it's a month of code or something because my dash is filled with people trying to learn Python. And that's great, because Python is a good language with a lot of support and job opportunities. I've just got some scattered thoughts that I thought I'd write down.

Python abstracts a number of useful concepts. It makes it easier to use, but it also means that if you don't understand the concepts then things might go wrong in ways you didn't expect. Memory management and pointer logic is so damn annoying, but you need to understand them. I learned these concepts by learning C++, hopefully there's an easier way these days.

Data structures and algorithms are the bread and butter of any real work (and they're pretty much all that come up in interviews) and they're language agnostic. If you don't know how to traverse a linked list, how to use recursion, what a hash map is for, etc. then you don't really know how to program. You'll pretty much never need to implement any of them from scratch, but you should know when to use them; think of them like building blocks in a Lego set.

Learning a new language is a hell of a lot easier after your first one. Going from Python to Java is mostly just syntax differences. Even "harder" languages like C++ mostly just mean more boilerplate while doing the same things. Learning a new spoken language in is hard, but learning a new programming language is generally closer to learning some new slang or a new accent. Lists in Python are called Vectors in C++, just like how french fries are called chips in London. If you know all the underlying concepts that are common to most programming languages then it's not a huge jump to a new one, at least if you're only doing all the most common stuff. (You will get tripped up by some of the minor differences though. Popping an item off of a stack in Python returns the element, but in Java it returns nothing. You have to read it with Top first. Definitely had a program fail due to that issue).

The above is not true for new paradigms. Python, C++ and Java are all iterative languages. You move to something functional like Haskell and you need a completely different way of thinking. Javascript (not in any way related to Java) has callbacks and I still don't quite have a good handle on them. Hardware languages like VHDL are all synchronous; every line of code in a program runs at the same time! That's a new way of thinking.

Python is stereotyped as a scripting language good only for glue programming or prototypes. It's excellent at those, but I've worked at a number of (successful) startups that all were Python on the backend. Python is robust enough and fast enough to be used for basically anything at this point, except maybe for embedded programming. If you do need the fastest speed possible then you can still drop in some raw C++ for the places you need it (one place I worked at had one very important piece of code in C++ because even milliseconds mattered there, but everything else was Python). The speed differences between Python and C++ are so much smaller these days that you only need them at the scale of the really big companies. It makes sense for Google to use C++ (and they use their own version of it to boot), but any company with less than 100 engineers is probably better off with Python in almost all cases. Honestly thought the best programming language is the one you like, and the one that you're good at.

Design patterns mostly don't matter. They really were only created to make up for language failures of C++; in the original design patterns book 17 of the 23 patterns were just core features of other contemporary languages like LISP. C++ was just really popular while also being kinda bad, so they were necessary. I don't think I've ever once thought about consciously using a design pattern since even before I graduated. Object oriented design is mostly in the same place. You'll use classes because it's a useful way to structure things but multiple inheritance and polymorphism and all the other terms you've learned really don't come into play too often and when they do you use the simplest possible form of them. Code should be simple and easy to understand so make it as simple as possible. As far as inheritance the most I'm willing to do is to have a class with abstract functions (i.e. classes where some functions are empty but are expected to be filled out by the child class) but even then there are usually good alternatives to this.

Related to the above: simple is best. Simple is elegant. If you solve a problem with 4000 lines of code using a bunch of esoteric data structures and language quirks, but someone else did it in 10 then I'll pick the 10. On the other hand a one liner function that requires a lot of unpacking, like a Python function with a bunch of nested lambdas, might be easier to read if you split it up a bit more. Time to read and understand the code is the most important metric, more important than runtime or memory use. You can optimize for the other two later if you have to, but simple has to prevail for the first pass otherwise it's going to be hard for other people to understand. In fact, it'll be hard for you to understand too when you come back to it 3 months later without any context.

Note that I've cut a few things for simplicity. For example: VHDL doesn't quite require every line to run at the same time, but it's still a major paradigm of the language that isn't present in most other languages.

Ok that was a lot to read. I guess I have more to say about programming than I thought. But the core ideas are: Python is pretty good, other languages don't need to be scary, learn your data structures and algorithms and above all keep your code simple and clean.

[fingors]

C — The Way It’s Written — Types

This is the first part in a possibly multi-part series of posts about the C programming language. It’s based not on common examples or what you’ll see your particular C compiler output, but on what’s written in the actual standard(s) that define the language. That being ISO/IEC 9899, in particular the 2018 revision (often named C17 or C18), however due to upcoming significant changes in the next revision (C2X), I’ll be skipping over a couple bits here and there that will be deprecated or removed by said revision, I’ll also revert to older versions if needed for special cases. All that being said, unless stated otherwise these posts are about C17. This series also assumes a baseline level familiarity with programming in general and expects you to know the general syntax style of C (if you’ve written or read and C++, Java, C#, or any similar language you’re good).

Due to the nature of C17 being an ISO/IEC document, it is not freely available for download, however the final working draft version of it is freely available, and there should be no significant changes between it and final. Link here.

Now, in what might seem like a very odd choice, we’re going to instantly skip to section 6 of the standard, not only that we’re skipping directly to 6.2.5 (page 31), because this is what defines the fundamental types of the language. Paragraphs 2, 4 and 6 are the important ones right now. From 2 we learn that the type _Bool (just bool in C2X) is at least large enough to hold the values 0 or 1 (hence its name, bool, short for boolean). Then we come to paragraph 4, which states there are 5 standard signed integer types: char, short, int, long, and long long (there’s also a statement about extended types but that can be ignored for the moment). Finally we hit paragraph 6, which simply states that all signed integer types have an unsigned equivalent that can be written by simply attaching the word unsigned to one of the types (ex. unsigned int), and that these 5 unsigned types combined with _Bool make up the set of unsigned types, and that any unsigned type takes up the same amount of storage/memory space as its corresponding signed type.

Moving back slightly to paragraph 5 we learn that signed char and char take the same amount of memory (and as such so does unsigned char), it also states that the int type should be the natural operating size of whatever machine architecture the code is being written for (so long as it satisfies a minimum value requirement). Moving forward to paragraph 9 we learn that, as you would expect, the signed types can store negative and positive values, and that the unsigned types can only store positive (or zero) values. We also learn that by definition unsigned values can not overflow, instead their value simply wraps around the range, however this is often referred to as overflow regardless.

Yet further down (paragraph 15, next page) we learn that char, signed char, and unsigned char are all different types, however char must match either char or unsigned char (the reasoning for this is that a compiler is free to choose the most efficient match for processing).

So with all that jumble out of the way what did we actually learn? Well: there exist 5 fundamental integer types: char, short, int, long, and long long, and that signed and unsigned versions of each exist, we also know there’s an unsigned type, _Bool that can represent the values 0 and 1. Together these make up the integer types of C.

Beyond integers there’s also floating point types, float, double, and long double, but those are a much more complicated subject that are outside the scope of this post. There’s also the void type, which has confusing wording that basically boils down to “you can’t use this, it represents nothing” (which is why functions with no return value have their return type marked void). And finally that you can make arrays out of these types (except void), make structure types that contain any number of these types (except void), make union types (complicated subject, think a box that can store only one type (except void) at a time), you can declare functions that return any type, you can have a pointer to any type (including void in order to represent a pointer to an unknown type), and finally that any type can be made atomic (safe for access from multiple threads).

Most of that statement can be freely ignored for now, it’s a mess that we’ll (hopefully) get into later. The important bit to know is that you can build other types out of the fundamental types.

Moving beyond that section and into 6.2.6 we learn from 6.2.6.1 Paragraphs 2-4 that objects (any type’s representation in memory basically) is made out of a continuous sequence of bytes. Moving to 6.2.6.2 we get to the representation of integer types, which is pretty much what you would expect for unsigned values (an unsigned integer of size n value bits can store 2n values from 0 to 2n-1), signed integer types in C17 list three different representations, however C2X is reducing that down to just twos’ complement (a signed integer of size n bits can store from -2n-1 to 2n-1-1, negative zeros are not possible).

So far: there exist integer types, and these store values in the expected way, but what are the range of values they must store?

Section 5.2.4.2.1 (page 20), paragraph 1 states that all implementations of the language must have the integer types be able to represent at least the values in the ranges listed below, meaning an implementation is free to expand the range if it sees fit (like how many do with int). From here we learn that a char must be at least 8 bits, and as such a signed char must be able to represent -127 (-128 in twos’ complement) to 127, and that an unsigned char is 0 to 255. Helpfully the actual (minimum) number of bits for each type is specified in a comment next to the definition. short is 16 bits/2 bytes, int is also 16 bits/2 bytes (again often expanded to 32 bits/4 bytes), long is 32 bits/4 bytes, and long long is 64 bits/8 bytes. _Bool due to its nature as a boolean type is not mentioned (actually any values placed into an object of type _Bool will become 0 if the value is 0 or 1 otherwise).

In summary: 6 types, _Bool (0 or 1), char (at least 8 bits), short (at least 16 bits), int (at least 16 bits, often 32), long (at least 32 bits), and long long (at least 64 bits).

So that’s it? For now yeah, those are the basic integer types of the C programming language, I know it was messy and weirdly formatted and confusing at times but I hope it helps understand the language a bit more, or at the very least was entertaining (even if that entertainment derived from “what the hell is this language?”). However, these complexities are part of the reason I love this language so much, everything is well defined but still variable depending on the system and compiler, there’s a reason for everything in this language ranging anywhere from “old” to “for performance reasons we can’t mandate this”, which if this series continues we’ll really get into. But for now, I hope this was enough of a taste of the standard to either make you interested in seeing more, or scare you the hell away forever. Thank you for reading and have a good time. If you have any suggestions for future parts or ways I could improve these writings please inform me. I need to go to sleep now.

[stumpyjoepete]

How does one actually learn how programming works? I started an online course in R but whenever I look at people talking about programming it's incomprehensible...where does everyone learn what type systems and inheritance and object oriented programming are?

(Sorry if this answer sucks, but I am trying to combat my natural perfectionist tendencies and give some answer to asks rather than guiltily ignoring them forever.)

Learn one particular common programming language. Get proficient enough to do a hobby project or something, and learn the internal terminology of the language and how to apply those concepts. Don’t worry about other languages. This is definitely the most important part, since by the end, you’ll actually know how to program, but you probably won’t have a well-developed vocabulary for talking about programming languages in the abstract or the differences between languages.

Learn some other common language. Treat it on its own terms, but you will inevitably find a lot of overlap with the first one you learned. This will help a lot with learning to separate the terminology/concepts within a given language from the more general concepts they are instantiating (e.g., the way “object oriented programming” and “inheritance” are handled in C++, java, javascript, go, and python are all very different in the details, even though they’re similarly shaped).

Dabble in a variety of languages (or take a “programming languages” survey course), learning just enough of each one to get a sense of what your existing conceptions of programming languages were missing. Aim for breadth and diversity rather than for depth or usefulness. (E.g., learn a little of something lispy like scheme, something ML-y like ocaml or haskell, etc.; rather than learning yet another popular imperative, vaguely object oriented language.) At this point, you will be very well equipped to talk about programming languages. (Another way of looking at this is that you are now cursed to talk about programming languages all the time.)

One thing that might not be obvious while you’re trudging through step 1 is that “learning” additional languages (especially if they’re very similar to languages you already know), is actually pretty easy. Now, if you want to be really good at programming in a particular language, that naturally takes time, but if I just want to investigate a language to figure out what makes it interesting, that’s easily doable in a day or two.

A really popular format for teaching programming languages to people who already are proficient in some other language is the “koan” approach, made popular by (I believe?) the Ruby community. It’s a bunch of prewritten code with some errors in it. You run the program, it eventually gets to some point where there’s a failed assertion or broken test, and it prints out an error. You look at the relevant example code and comments (which are teaching a basic concept within the language), you make the one or two line change, and you rerun it. There are usually several dozen examples, each teaching something different. They start with familiar things (e.g., you already know how if-statements work in some other language, here’s how they work in this language) and gradually work up to the features that make the programming language unique.

Here’s a big list of “koans” for different programming languages.

[itview12-blog]

How to make a fruitful profession in Python

From requesting food, driving to our office to connecting with a companion, we have portable/web applications to get it going. Along these lines, it wouldn't not be right to state that Software improvement and web applications are running the world. Learning the programming dialects can accept you higher than ever as it is the center of the innovation. Securing it will make you fit for building, executing, and troubleshooting new applications. One of the dialects that are in a blast right currently is Python. All the main organizations like Google, Facebook, and Netflix make tweak their product utilizing this language. As indicated by The Importance of Being Earnest (TIOBE) record, Python will assume control over Java and C language in the following four to five years. (TIOBE is a programming network list that quantifies the prevalence of programming dialects.) Python is getting praises as a result of its basic language structure, simple difficulty highlight, quicker code meaningfulness, succinctness. Profession Path in Python There are a great deal of approaches to get into programming creating and learning new dialects. At first, you can seek after programming designing or software engineering and afterward improve your aptitudes with affirmation courses. IT View, which is a main Python Training Institute in Pune will show you the correct way to make a vocation in this field. Choices in Different Disciplines Information Science and Machine Learning (ML)/Artificial Intelligence (AI) AI which is identified with AI is an innovation that gets to information without human cooperation by getting calculations. Information Science is an innovation that determines bits of knowledge utilizing explicit calculations from organized/unstructured information. Python is generally used to assemble applications for organizations that need to deal with their information utilizing ML or information science, as it has exact linguistic structure, code proficiency. In addition, it tends to be joined with different dialects. Web Development Learning Python can land you at the situation of a web engineer in a built up firm in light of the fact that nearly everyone is slanting towards the language. Python is good since it fills the general-need and offers various systems. Each organization needs a novel and altered site. On the off chance that it is constructed utilizing Python it will assist you with creating perfect versatile just as work area adaptations, catboats fit with AI innovation, strong activitys. Web of Things (IoT) IoT is fundamentally an arrangement of interconnected gadgets having interesting IP tends to that are fit for sharing and moving information either by human-to-human or human-to-PC connections. IoT is normally utilized for information investigation and subsequently the product ought to be simple and adaptable. Utilizing Python to make these frameworks will be an ideal decision, as the language is extensible, simple to code, and embeddable. Full-Stack The full-stack engineers are all-rounder as they build up the front end, fabricate the back end, make database servers, adaptation controlling frameworks, and API. They convert customer requests into application and sites. Python language is a famous choice for full-stack designers as it is a universally handy, elevated level language that gives an open-source, suits all applications. Python permits you to execute programming as well as all speak with one another. Utilizing this programming language requires less coding directions in addition to it gives adaptability, moderateness, a lot of structure stacks, and extent of customizations. Selenium Automation Testing Tool Selenium is the most famous open-source device utilized for programming testing since it permits utilitarian testing, in addition to records and playbacks while utilizing the instrument. It very well may be utilized to test different contents across changed programs. The instrument underpins various dialects, jumps and continually presents new updates. Utilizing Python in selenium grants you to run tests and code inclusion parallely and goes about as a scaffold between test code and cases. Python has basic linguistic structure, can be scripted in a few different ways, it is object-situated, interpretative, and flexible, and consequently fits in with the instrument consummately. Distributed computing (Aws) and DevOps Numerous organizations are receiving cloud computerization since it can work in various areas likewise it is modest and simple to keep up. Python improved Aws and DevOps are in the blast since it effectively unravels the complexities happened in cloud tasks. It is adaptable such that it offers a few arrangements of structures that are perfect with the elements of both the instruments. Its consistent updates offer a chance to make engaging archives under a concentrated framework. Experts of Choosing to Be a Python Developer You get the opportunity to utilize a wide scope of libraries and apparatuses while scripting in the Python language. A plentiful measure of openings for work are accessible for what it's worth sought after and as of late began picking up prevalence. On the off chance that you are slanted towards ML or AI than Python is a great choice for you. Python can be made under the OSI-endorsed open source that empowers the business uses to utilize and appropriate it helpfully Utilizing Python causes the designer to make an easy to use, quick, and dynamic information structures. It builds profitability as the structures made by python have, own unit testing system, process convention, solid incorporation, improved content handling. Python bolster library gives a criticized code that lessens the length of the code. End On the off chance that you need a fruitful profession in creating, scripting and constructing applications at that point learning Python is the need of great importance. Connecting with the top-evaluated establishments will open numerous opportunities for you. ITView is an expertly overseen Software Training Institute, trying to develop as an unmistakable learning place at different IT centers of Country. ITView has a group of top-evaluated mentors that train and guide you to get to know Python.

[blubberquark]

Teaching to RTFM

I think RTFM has its place. I know I’m not in the minority with this view, but it’s not exactly polite to talk about it. We have all started out on the other side of RTFM at some point, clueless and helpless, not knowing where to begin.

To be quite honest, I wasn’t told to RTFM that much, because I learned to program from books when I was 12, and I wished I could ask somebody for guidance. My father still knew BASIC from the late 70s and early 80s, and my teachers knew enough PASCAL to pass their own exams and then teach children how to use Microsoft Excel. There was nobody to turn to.

When I started learning Java from a book, I was very confused, and I learned many bad habits, idiosyncrasies of the book’s author that I stuck with because I didn’t understand what they meant. Then I bought a bigger, heavier book about Java, and I slowly learned to program. I learned programming in general and Java in particular at the same time. One textbook explained what classes in Java do, but not why you would use them, and the other textbook vacillated between treating OOP as a scary newfangled concept nobody understands but everybody has to use because of Java, and something you have to be familiar with already because the book assumed you already knew C, C++, BASIC and smalltalk.

I read the manual and I didn’t understand. What finally got me to understand OOP was ironically learning and reading code in Python. Unlike in Java and smalltalk, OOP in Python is optional. Although everything in Python is an object, the common Pythonic programming style is procedural, with OOP constructs used sparingly when they make sense. This finally let me understand what OOP is good for. No amount of contrived examples like “class PickUpTruck extends Car { ... }“ helped me understand OOP in Java.

The same thing can happen with classes, module systems, macros, build systems, version control systems, bug trackers, databases, and visual modelling languages like UML and FMC. They are all paradigms or technologies to manage complexity, and if I give a student a toy teaching example of a SQL database, multi-module program, or UML diagram, then the student will be confused rather than enlightened. If the complexity is missing from the example, then the benefit of using complexity-mitigating technology is not obvious.

That even goes for comments! What good are comments in a textbook example, with explanatory text already left and right of the code listing?

If I had a teacher who could explain OOP to me, things would have been so much easier. Eventually, I managed to learn what I needed to learn. Some things are much, much harder to learn if you can’t ask a teacher multiple clarificatory question in quick succession. It would be even better if your teacher asked you a couple of questions to drill down on which part you didn’t understand.

Nowadays, I see many questions on Discord, IRC, and forums from people who are just starting out learning to program. It’s a vast difference between learning Unity3D when you are already a programmer who shipped software in C++ and wrote games in Java, and learning programming, C#, game design, level design, shaders, 3D modelling, and the Unity3D Engine in one go.

If somebody asks a confused question online, the first order of business is to establish whether they are an expert or a confused beginner. That can sound confusing and condescending, but I often fear if I give a straight answer to a confused question, I do more harm than good.

When somebody asks “How do I iterate over the pixels in a pygame surface?“, I can give the straight answer, or three advanced answers with different performance characteristics. You probably want to use numPy and cache the results during level loading. Maybe you can also use numPy if it’s only an occasional thing, and you can stomach the dozens of megabytes of native code dependencies. You probably want to use OpenGL with a GLSL fragment shader if you do the thing every frame. If perchance you want to do palette-swaps only, then you can use the pygame palette handing functions rather than iterating over pixels and doing a dict look-up each time. Iterating over all the pixels in a pygame surface is slow. You can probably get away with it on a 16x16 sprite, but not on a 1920x1080 screenshot.

That’s not even the worst of it! I see confused questions by people who think they found a bug in a library/framework/engine, but actually they just don’t understand their own code, or they don’t understand the programming language. I see confused questions by people who don’t know what problem they are actually encountering, who don’t know what to Google.

These people don’t need to be told to RTFM. Either they already read the manual, but they don’t understand it, or they don’t even know which manual, or what to look for. They can’t be told to RTFM, but they can’t be given straight answers either. The best thing you can do is to ask “You’re new to this, aren’t you?“ and point them to a more basic tutorial. Or, if your time is worthless, you can decide to tutor them one-on-one over the Internet.

All these problems can combine into the worst possible scenario: Somebody asks on StackOverflow/IRC/the mailing list/Slack/Discord, because their teacher is not available, or told them to learn to RTFM and figure it out independently. These people can be high school students too intimidated by their teachers to ask questions, university students who can’t be bothered to attend lectures or wait for office hours, or junior programmers who are trying to impress their boss.

Figuring things out is a useful skill to have, but it’s not something you should rely on in a high school class. If you’re a teacher, don’t punish students for asking questions! And don’t expect students to bother strangers on the Internet to do your job for you. The best thing you can do to get students to RTFM is to answer their questions when they get stuck, so they get a good idea of what to look for, which terms to search for, what to ask on IRC.

If you want to teach your pupils to RTFM, you should at least follow up with them and point them in the right direction in case they get stuck trying to look up the answer, or if they don’t understand the text in the manual. Of course you can assign reading, but for some reason, some of your pupils will take this to mean that you refuse to explain the topic, so the only recourse is to ask strangers online.

And then the student comes back next week and asks even more confused questions, now that the next assignment is due, impossible to complete without having understood last week’s topic.

Around a third of confused newbie questions I see are from students who would rather not ask their teachers, not even those who post whole homework assignments.

Some people want us to stop saying RTFM online, ever. They also want us to stop saying “You’re new to this, aren’t you?“ or “Please take a step back and think about what you are trying to accomplish with this“. They all are too condescending. I’m not just trying to shift the blame away from open source projects and programmer online communities. Confused online questions sometimes have offline causes. These causes cannot be hyperlinked, retroactively screenshotted, and posted to twitter.

For all the talk of rudeness online, many students would rather ask questions here than at school. Maybe the problem lies in the classroom.

[baeddel]

radical-eirini

imo starting with C or assembly is bullshit. Start with Java or C# to learn a basic programming language and object oriented programming. Learn F# or OCaml after to learn functional programming.

That sounds good yea... I started w/ python >< I feel like python is more than fine even though obviously you need to get used to all the things that python does for you when you go to other languages and yr gonna miss some stuff thats fundamental to how programs work. But I just dont think thats too big a deal vs, like, writing programs, and getting to write programs and see how they work and respond to your code and encountering and overcoming those problems is like, the process that teaches you the most and it doesn’t matter what you learn so much as long as you get there. Thats how I feel as a beginner anyway, ofc my perspective is somewhat limited... but like the difference between following along a textbook and doing the exercises, and making my first program on my own was like the difference between looking at a picture of a lake and swimming in it, you know?

The next thing I’m going to learn is javascript because I wanna make browser games and thats like a v natural thread based on my route thru programming even though it isn’t, like, what a university would get you to do or w/e. I do want to learn Scheme at some point though so I can work thru Structure and Interpretation of Computer Programs, which I got a couple of years ago intending to do, but I dont really feel ready for it yet and I dont think I need to rush there...