OSDev.org

Seasoft wrote:ECMA/JavaScript sounds like a lame idea for a //first language.

vvaltchev wrote:* The problem with C++ is that, while is all-powerful, is too complicated and expert-friendly to start with.

Solar wrote:The problem with C++ is that it requires a really good instructor. Done right, you can get all the way through an introduction course and halfway into an intermediate course without even mentioning pointers, or indeed arrays. And today, "manual memory management" is something for library implementors, if even that. Unless you are programming an allocator, you should never have to write "new" or "delete".

Solar wrote:The problem with C++ is that it requires a really good instructor. Done right, you can get all the way through an introduction course and halfway into an intermediate course without even mentioning pointers, or indeed arrays. And today, "manual memory management" is something for library implementors, if even that. Unless you are programming an allocator, you should never have to write "new" or "delete".

Solar wrote:The problem with C++ is that it requires a really good instructor.

vvaltchev wrote:That's the modern mainstream approach towards teaching C++, pushed by most C++ evangelists and by Stroustrup himself. I oppose this approach, despite its high-profile advocates. It's all about teaching modern C++ AS IF it was a managed language like Java or C#. It goes like: "use vector<T>, map<T>, make_unique(), make_shared(), etc. follow the _rules_ and it will work". The problem with that is: what happens when we do make a mistake? In managed languages, mistakes have a much limited effect compared to unmanaged ones. Null pointer? Exception. Out of bounds? Exception. Use after free / double free? Cannot have that with GC. Uninitialized memory? There's no such thing in managed languages I know.

Solar wrote:Java can have dangling references, or unreachable objects still referenced, leading to resource leaks.

Solar wrote:Java claims it is free of pointers, but does throw a literal NullPointerException on occasion. You have a String object that might not actually be a String object because it is actually NULL pointers? In its way, Java is more backward than C++. And it's not without pointers, it is all pointers, it's just lying through its teeth about it.

Solar wrote:C++ can be used as a language without manual memory management, without C arrays, and yes, to a large degree without using pointers. And you know what? Your code will be shorter, more expressive, and more robust that way.

Solar wrote:Going from C to C++ in tiny steps is hard.

Solar wrote:Starting with C++, the real C++ taught by an instructor who knows that all the C stuff is for backward compatibility only -- that is such an easy learning experience you wouldn't believe it.

vvaltchev wrote:How could you create a linked list?

public class List<T> {
  interface Node {
    bool isEnd();
    Node getNext();
    T getVal();
  }
  private Node first;
  class EmptyNode implements Node {
    EmptyNode() {}
    bool isEnd() { return true; }
    Node getNext() { throw new NotImplementedException(); }
    T getVal() { throw new NotImplementedException(); }
  }
  class FullNode implements Node {
    private Node n;
    private T val;
    FullNode(T v, Node nx) { n = nx; val = v; }
    bool isEnd() { return false; }
    Node getNext() { return n; }
    T getVal() { return val; }
  }
  class ListIterator implements Iterator {
    private Node n;
    ListIterator(Node node) { n = node; }
    bool hasNext() { return !n.isEmpty(); }
    T next() {
      T val = n.getVal();
      n = n.getNext();
      return val;
    }
  }
  List() { first = new EmptyNode(); }
  void PushFront(T v) { first = new FullNode(v, first); }
  Iterator iterator() { return new ListIterator(first); }
}

vvaltchev wrote:Anyway, I'm forcing myself to stop here. No intention in fighting another war. I've expressed my opinion, you have expressed yours, that's enough. Readers will make up their own mind.

Nobody talking about Java has ever hidden the fact that all objects are pointers. Having NULL pointers is absolutely natural a concept for most programming languages. It's not a defect.

How could you create a linked list? You cannot have an infinite amount of objects. Having a NULL "next" pointer is exactly what we want.

my_class x{ 42 };
std::forward_list< my_class > list;
list.push_back( x );

nullplan wrote:

vvaltchev wrote:How could you create a linked list?

With interfaces.

nullplan wrote:Excuse syntax errors in the above code, I haven't done this in a while. In any case, as you can see, not a single null reference is present or desired. Object oriented programming allows you to do things very differently from pure procedural programming. I do not think having all references be nullable is a good thing. In C++, references are never NULL. There is a separate type to denote the possibility for an object to not be filled (called Nullable, similar to Haskell's Maybe), and so you cannot pass a reference that may be NULL to a function that can't deal with it.

nullplan wrote:Using the type system to detect such errors is one of the hallmarks of higher level programming, so it is a bit of a shame to see people not take advantage of it. In C, I have started using small structs all over the place to keep several low-level things apart from each other. I have a struct for 4-byte little endian values, and 4-byte big endian values, and functions to translate between those and actual integers. I never have to deal with byte swapping ever again!

struct list_node {
   struct list_node *next;
   struct list_node *prev;
};

struct list {
   struct list_node *first;
   struct list_node *last;
};

Solar wrote:It's not a war; it really isn't, not for me. This is relaxed chat, for me. If it isn't for you, sorry, and this is my last post on the matter as well.

Solar wrote:This is something I have experience in, and if you and I had the time (I don't, though, sorry) I'd love to show you what I mean in practice. I completely understand your POV, I've been there not that long ago myself. I even started an online blog series to teach C++ "ground up", "oldschool", which was how I learned it myself after all.

Which was exactly when I realized how many problems you create that way.

Solar wrote:Not a defect, but a crutch, dating back to a time when pointers were all we had. You don't need pointers when you can have references -- which, incidentially, can never be NULL. References are simply superior to pointers in every conceivable way.

Solar wrote:See? You think "linked list", and immediately think about its innards, about the "next pointer" in there. I think "linked list" and immediately know that that's a standard container I can just use.

Solar wrote:Thinking about innards, thus breaking the abstraction, is exactly the kind of thinking that perpetuates problem of people approaching C++ bottom-up. It absolutely does not matter how a linked list works internally, because we have a complete implementation available.

Solar wrote:The most aggravating thing I know is instructors asking their students to re-implement standard functionality (like writing their own list class, or implementing bubblesort). It's wasted time; chances are you never will have to actually write anything like that in the field -- not if you did spend that time learning what is already there, and how to use it, instead on how to re-implement it.