ITopic: What to do after Scratch Guide (IMPORTANT)

TheUltimatum

Blaze349 wrote:
ateesdalejr wrote:
nano will rule you all.

Yes.

solve the cube

Blaze349

myothercarisacdr wrote:
For game engines, what about OpenGL?

OpenGL is a graphics framework in the same category as directX and Metal. It isn't a game engine.

Visit Christian HQ.

PrincessPanda_test_

You forgot about Roblox. You can create games with it, which are like REAL games.

Jonathan50

PrincessPanda_test_ wrote:
You forgot about Roblox. You can create games with it, which are like REAL games.

Why wouldn't they be real games? But the OP isn't on Scratch anymore

Not yet a Knight of the Mu Calculus.

PrincessPandaLover

Blaze349 wrote:
4. Gimp

Gimp is seen as a free replacement to the more expensive Photoshop. Gimp is an excellent program but is a little hard to grasp.

Used GIMP since I was like 10. Is that good?

HERE COMES THE MONEH!

MONEH MONEH MONEH MONEH

Jonathan50

PrincessPandaLover wrote:
Is that good?

Yes

Not yet a Knight of the Mu Calculus.

Inkulumo

Surprised Notepad++ isn't on the list. Not surprised Valve's Source engine isn't on the list.

code to easily find my posts: ZGVjb2RlcmF0ZWQ=

serprinss

good js library p5.js

GENERATION 364: The first time you see this, copy it into your sig on any forum and add 1 to the generation. Social experiment. I did not start this.

Inkulumo

add source engine

code to easily find my posts: ZGVjb2RlcmF0ZWQ=

smileycreations15

What? Nano is slow? GUIs eat up more memory!!!!!!!
My recommendations for beginners:

nano
vim

bye

MegaApuTurkUltra

smileycreations15 wrote:
What? Nano is slow? GUIs eat up more memory!!!!!!!
My recommendations for beginners:
nano
vim

I think they meant nano is slow to use. It doesn't really offer the advanced shortcuts that vim or emacs have that make editing orders of magnitude faster than in a gui editor. But it's also easy for people who are new to terminal editors

if you're ready to move to an advanced editor like vim or emacs it can still be kinda daunting because out of the box they don't come with a lot of the config or extra packages that make them useful. I recommend starting with spacevim or spacemacs as they come with a lot of good packages and configuration done for you

$(".box-head")[0].textContent = "committing AT crimes since $whenever"

ResExsention

Useful, but I must point out a few things.

First of all, why are you suddenly dragging people into making 3D games? Making models is difficult (believe me, making just a donut in Blender took hours), and Maya isn't good for games (it's better for animations, it's 3DSMax that you want, also by Autodesk). Plus, anything made by Autodesk costs thousands of dollars!

Next, I think you should really explore other game engines aside from Unity and Unreal. Sure, they both are really good, but I don't think you should limit people to AAA engines, when they may only need something simple. Plus, they both hijack your game with a splash screen you can't remove. Maybe you should also list an open source, no royalty game engine like Godot so that if they don't want AAA class companies getting in their way, well, yeah.

Next, I disagree about GIMP. I tried it once, but I found it a bit complicated. I use Krita now, which is also free.

Next, do not start with C. C++ is actually easier than C. C is generally a very messy language, and learning C++ after could result in confusion. You want the + more than the C. Additionally, the purpose of C++ was to make C easier, not make it more complicated. That's why C was remade. I also don't recommend C, again, because of the messiness of it.

Next, why don't you recommend Visual Studio or Visual Studio Code? I personally use it, please give your reasons. Even though they both have a learning curve, doesn't everything else does? Additionally, why are you mentioning sublime? It costs money!

But overall, a good starting point, but could use some improvement.

Last edited by ResExsention (May 21, 2019 05:58:52)

Infrequently active.

It feels weird to see how far we've come. I hope you're well, wherever you are!

MegaApuTurkUltra

ResExsention wrote:
Next, do not start with C. C++ is actually easier than C. C is generally a very messy language, and learning C++ after could result in confusion. You want the + more than the C. Additionally, the purpose of C++ was to make C easier, not make it more complicated. That's why C was remade. I also don't recommend C, again, because of the messiness of it.

You think C is messy?
take a look at <unordered_map>

template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
          class Alloc = allocator<pair<const Key, T>>>
class unordered_map
{
public:
    // types
    typedef Key                                                        key_type;
    typedef T                                                          mapped_type;
    typedef Hash                                                       hasher;
    typedef Pred                                                       key_equal;
    typedef Alloc                                                      allocator_type;
    typedef pair<const key_type, mapped_type>                          value_type;
    typedef value_type&                                                reference;
    typedef const value_type&                                          const_reference;
    typedef typename allocator_traits<allocator_type>::pointer         pointer;
    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
    typedef typename allocator_traits<allocator_type>::size_type       size_type;
    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
    typedef /unspecified/ iterator;
    typedef /unspecified/ const_iterator;
    typedef /unspecified/ local_iterator;
    typedef /unspecified/ const_local_iterator;
    typedef unspecified                             node_type;            // C++17
    typedef INSERT_RETURN_TYPE<iterator, node_type> insert_return_type;   // C++17
    unordered_map()
        noexcept(
            is_nothrow_default_constructible<hasher>::value &&
            is_nothrow_default_constructible<key_equal>::value &&
            is_nothrow_default_constructible<allocator_type>::value);
    explicit unordered_map(size_type n, const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
    template <class InputIterator>
        unordered_map(InputIterator f, InputIterator l,
                      size_type n = 0, const hasher& hf = hasher(),
                      const key_equal& eql = key_equal(),
                      const allocator_type& a = allocator_type());
    explicit unordered_map(const allocator_type&);
    unordered_map(const unordered_map&);
    unordered_map(const unordered_map&, const Allocator&);
    unordered_map(unordered_map&&)
        noexcept(
            is_nothrow_move_constructible<hasher>::value &&
            is_nothrow_move_constructible<key_equal>::value &&
            is_nothrow_move_constructible<allocator_type>::value);
    unordered_map(unordered_map&&, const Allocator&);
    unordered_map(initializer_list<value_type>, size_type n = 0,
                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                  const allocator_type& a = allocator_type());
    unordered_map(size_type n, const allocator_type& a)
      : unordered_map(n, hasher(), key_equal(), a) {}  // C++14
    unordered_map(size_type n, const hasher& hf, const allocator_type& a)
      : unordered_map(n, hf, key_equal(), a) {}  // C++14
    template <class InputIterator>
      unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
      : unordered_map(f, l, n, hasher(), key_equal(), a) {}  // C++14
    template <class InputIterator>
      unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf, 
        const allocator_type& a)
      : unordered_map(f, l, n, hf, key_equal(), a) {}  // C++14
    unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
      : unordered_map(il, n, hasher(), key_equal(), a) {}  // C++14
    unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf, 
      const allocator_type& a)
      : unordered_map(il, n, hf, key_equal(), a) {}  // C++14
    ~unordered_map();
    unordered_map& operator=(const unordered_map&);
    unordered_map& operator=(unordered_map&&)
        noexcept(
            allocator_type::propagate_on_container_move_assignment::value &&
            is_nothrow_move_assignable<allocator_type>::value &&
            is_nothrow_move_assignable<hasher>::value &&
            is_nothrow_move_assignable<key_equal>::value);
    unordered_map& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;
    bool      empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    iterator       begin() noexcept;
    iterator       end() noexcept;
    const_iterator begin()  const noexcept;
    const_iterator end()    const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend()   const noexcept;
    template <class... Args>
        pair<iterator, bool> emplace(Args&&... args);
    template <class... Args>
        iterator emplace_hint(const_iterator position, Args&&... args);
    pair<iterator, bool> insert(const value_type& obj);
    template <class P>
        pair<iterator, bool> insert(P&& obj);
    iterator insert(const_iterator hint, const value_type& obj);
    template <class P>
        iterator insert(const_iterator hint, P&& obj);
    template <class InputIterator>
        void insert(InputIterator first, InputIterator last);
    void insert(initializer_list<value_type>);
    node_type extract(const_iterator position);                                       // C++17
    node_type extract(const key_type& x);                                             // C++17
    insert_return_type insert(node_type&& nh);                                        // C++17
    iterator           insert(const_iterator hint, node_type&& nh);                   // C++17
    template <class... Args>
        pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);          // C++17
    template <class... Args>
        pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);               // C++17
    template <class... Args>
        iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17
    template <class... Args>
        iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);      // C++17
    template <class M>
        pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);            // C++17
    template <class M>
        pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);                 // C++17
    template <class M>
        iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);   // C++17
    template <class M>
        iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);        // C++17
    iterator erase(const_iterator position);
    iterator erase(iterator position);  // C++14
    size_type erase(const key_type& k);
    iterator erase(const_iterator first, const_iterator last);
    void clear() noexcept;
    template<class H2, class P2>
      void merge(unordered_map<Key, T, H2, P2, Allocator>& source);         // C++17
    template<class H2, class P2>
      void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);        // C++17
    template<class H2, class P2>
      void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);    // C++17
    template<class H2, class P2>
      void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);   // C++17
    void swap(unordered_map&)
        noexcept(
            (!allocator_type::propagate_on_container_swap::value ||
             __is_nothrow_swappable<allocator_type>::value) &&
            __is_nothrow_swappable<hasher>::value &&
            __is_nothrow_swappable<key_equal>::value);
    hasher hash_function() const;
    key_equal key_eq() const;
    iterator       find(const key_type& k);
    const_iterator find(const key_type& k) const;
    size_type count(const key_type& k) const;
    pair<iterator, iterator>             equal_range(const key_type& k);
    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
    mapped_type& operator[](const key_type& k);
    mapped_type& operator[](key_type&& k);
    mapped_type&       at(const key_type& k);
    const mapped_type& at(const key_type& k) const;
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type& k) const;
    local_iterator       begin(size_type n);
    local_iterator       end(size_type n);
    const_local_iterator begin(size_type n) const;
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
};

now explain what all of this means

I do not recommend learning C++ first.

Learn Racket first.

$(".box-head")[0].textContent = "committing AT crimes since $whenever"

ResExsention

MegaApuTurkUltra wrote:

ResExsention wrote:
Next, do not start with C. C++ is actually easier than C. C is generally a very messy language, and learning C++ after could result in confusion. You want the + more than the C. Additionally, the purpose of C++ was to make C easier, not make it more complicated. That's why C was remade. I also don't recommend C, again, because of the messiness of it.

You think C is messy?
take a look at <unordered_map>

template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
          class Alloc = allocator<pair<const Key, T>>>
class unordered_map
{
public:
    // types
    typedef Key                                                        key_type;
    typedef T                                                          mapped_type;
    typedef Hash                                                       hasher;
    typedef Pred                                                       key_equal;
    typedef Alloc                                                      allocator_type;
    typedef pair<const key_type, mapped_type>                          value_type;
    typedef value_type&                                                reference;
    typedef const value_type&                                          const_reference;
    typedef typename allocator_traits<allocator_type>::pointer         pointer;
    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
    typedef typename allocator_traits<allocator_type>::size_type       size_type;
    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
    typedef /unspecified/ iterator;
    typedef /unspecified/ const_iterator;
    typedef /unspecified/ local_iterator;
    typedef /unspecified/ const_local_iterator;
    typedef unspecified                             node_type;            // C++17
    typedef INSERT_RETURN_TYPE<iterator, node_type> insert_return_type;   // C++17
    unordered_map()
        noexcept(
            is_nothrow_default_constructible<hasher>::value &&
            is_nothrow_default_constructible<key_equal>::value &&
            is_nothrow_default_constructible<allocator_type>::value);
    explicit unordered_map(size_type n, const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
    template <class InputIterator>
        unordered_map(InputIterator f, InputIterator l,
                      size_type n = 0, const hasher& hf = hasher(),
                      const key_equal& eql = key_equal(),
                      const allocator_type& a = allocator_type());
    explicit unordered_map(const allocator_type&);
    unordered_map(const unordered_map&);
    unordered_map(const unordered_map&, const Allocator&);
    unordered_map(unordered_map&&)
        noexcept(
            is_nothrow_move_constructible<hasher>::value &&
            is_nothrow_move_constructible<key_equal>::value &&
            is_nothrow_move_constructible<allocator_type>::value);
    unordered_map(unordered_map&&, const Allocator&);
    unordered_map(initializer_list<value_type>, size_type n = 0,
                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                  const allocator_type& a = allocator_type());
    unordered_map(size_type n, const allocator_type& a)
      : unordered_map(n, hasher(), key_equal(), a) {}  // C++14
    unordered_map(size_type n, const hasher& hf, const allocator_type& a)
      : unordered_map(n, hf, key_equal(), a) {}  // C++14
    template <class InputIterator>
      unordered_map(InputIterator f, InputIterator l, size_type n, const allocator_type& a)
      : unordered_map(f, l, n, hasher(), key_equal(), a) {}  // C++14
    template <class InputIterator>
      unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf, 
        const allocator_type& a)
      : unordered_map(f, l, n, hf, key_equal(), a) {}  // C++14
    unordered_map(initializer_list<value_type> il, size_type n, const allocator_type& a)
      : unordered_map(il, n, hasher(), key_equal(), a) {}  // C++14
    unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf, 
      const allocator_type& a)
      : unordered_map(il, n, hf, key_equal(), a) {}  // C++14
    ~unordered_map();
    unordered_map& operator=(const unordered_map&);
    unordered_map& operator=(unordered_map&&)
        noexcept(
            allocator_type::propagate_on_container_move_assignment::value &&
            is_nothrow_move_assignable<allocator_type>::value &&
            is_nothrow_move_assignable<hasher>::value &&
            is_nothrow_move_assignable<key_equal>::value);
    unordered_map& operator=(initializer_list<value_type>);
    allocator_type get_allocator() const noexcept;
    bool      empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    iterator       begin() noexcept;
    iterator       end() noexcept;
    const_iterator begin()  const noexcept;
    const_iterator end()    const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend()   const noexcept;
    template <class... Args>
        pair<iterator, bool> emplace(Args&&... args);
    template <class... Args>
        iterator emplace_hint(const_iterator position, Args&&... args);
    pair<iterator, bool> insert(const value_type& obj);
    template <class P>
        pair<iterator, bool> insert(P&& obj);
    iterator insert(const_iterator hint, const value_type& obj);
    template <class P>
        iterator insert(const_iterator hint, P&& obj);
    template <class InputIterator>
        void insert(InputIterator first, InputIterator last);
    void insert(initializer_list<value_type>);
    node_type extract(const_iterator position);                                       // C++17
    node_type extract(const key_type& x);                                             // C++17
    insert_return_type insert(node_type&& nh);                                        // C++17
    iterator           insert(const_iterator hint, node_type&& nh);                   // C++17
    template <class... Args>
        pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);          // C++17
    template <class... Args>
        pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);               // C++17
    template <class... Args>
        iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args); // C++17
    template <class... Args>
        iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);      // C++17
    template <class M>
        pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);            // C++17
    template <class M>
        pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);                 // C++17
    template <class M>
        iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);   // C++17
    template <class M>
        iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);        // C++17
    iterator erase(const_iterator position);
    iterator erase(iterator position);  // C++14
    size_type erase(const key_type& k);
    iterator erase(const_iterator first, const_iterator last);
    void clear() noexcept;
    template<class H2, class P2>
      void merge(unordered_map<Key, T, H2, P2, Allocator>& source);         // C++17
    template<class H2, class P2>
      void merge(unordered_map<Key, T, H2, P2, Allocator>&& source);        // C++17
    template<class H2, class P2>
      void merge(unordered_multimap<Key, T, H2, P2, Allocator>& source);    // C++17
    template<class H2, class P2>
      void merge(unordered_multimap<Key, T, H2, P2, Allocator>&& source);   // C++17
    void swap(unordered_map&)
        noexcept(
            (!allocator_type::propagate_on_container_swap::value ||
             __is_nothrow_swappable<allocator_type>::value) &&
            __is_nothrow_swappable<hasher>::value &&
            __is_nothrow_swappable<key_equal>::value);
    hasher hash_function() const;
    key_equal key_eq() const;
    iterator       find(const key_type& k);
    const_iterator find(const key_type& k) const;
    size_type count(const key_type& k) const;
    pair<iterator, iterator>             equal_range(const key_type& k);
    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
    mapped_type& operator[](const key_type& k);
    mapped_type& operator[](key_type&& k);
    mapped_type&       at(const key_type& k);
    const mapped_type& at(const key_type& k) const;
    size_type bucket_count() const noexcept;
    size_type max_bucket_count() const noexcept;
    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type& k) const;
    local_iterator       begin(size_type n);
    local_iterator       end(size_type n);
    const_local_iterator begin(size_type n) const;
    const_local_iterator end(size_type n) const;
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;
    float load_factor() const noexcept;
    float max_load_factor() const noexcept;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
};

now explain what all of this means

I do not recommend learning C++ first.

Learn Racket first.

Well, I do. Fine, I concede that C isn't messy. But it still isn't worth learning.

Again, may I mention that the OP throws people straight into 3D games and 3D modelling? I tried to do that to myself once but quit quite fast. I can do both now, but even the simplest models take a long time to make. I don't think people just leaving Scratch should be thrown into that.

However, just because C++ has more features than C doesn't mean it's more complicated. I personally learned C++ first, and I really enjoyed the language. Then, I tried to learn C, but promptly quit because I began to confuse the two.

I will have to say that people should choose one or the other, because it will just result in confusion between them. If you won't recommend C++, you might want to try C#. Anyway, C is quite an old language, and it isn't very fast, either, so I don't see why people should stick with it. You want the plus or sharp version of C, believe me.

Anyway, let me translate that code.

Essentially, it creates a template (just like it sounds) using various classes, including T, which is standard for templates.

Then, the class unordered_map is declared, and numerous type definitions are given aliases using typedef, perhaps to refer to them easier? I personally don't use typdef.

Wow. What happens after is messy. I can't really read it.

Anyway, the function unordered_map is called and noexcept is used to define whether a function will throws exceptions for certain things.

Not familiar with explicit. I'm recalling my C++ knowledge here. I don't really know C, but they are similar.

Then, it calls more unordered_map, with varying arguments. Apparently, unordered_map was declared more than once to accept different arguments. What is unordered_map anyway?

Then, it defines two more templates, using class InputIterator. In between it calls unordered_map again inheriting from the template. More unordered_map is called.

The destructor for the class is defined with unordered_map~(); Seems like unordered_map is the constructor. Appears to be that the function definitions are in a separate file.

Then, utilizing pointers, the constructor is called again.

An allocator is then defined. Constant variables are also defined, with the property of noexcept.

More templates and pairs.

Various functions are defined, such as insert and extract.

An iterator is used with the void insert function.

More templates.

Iterators are defined.

A function with the return type of void is defined (clear) and has the noexcept property.

Templates and functions.

Swap is defined with the return type of void. Another noexcept clause definition.

And then functions are defined. Those functions likely has definitions in a separate file.

See what I mean? C is really lacking. private, public, and protected did not appear in the class definition, and some of the clauses used go redundant in C++ and C#. Again, just because they have more features doesn't mean it's more complicated.

Again, I was calling on C++ knowledge, I am not really familiar with C.

And again, everything is subjective.

Infrequently active.

It feels weird to see how far we've come. I hope you're well, wherever you are!

MegaApuTurkUltra

ResExsention wrote:
snip

not to be rude, but it really sounds like you haven't written a whole lot of C++ yet. I'd advise you to fully familiarize yourself with the language and do at least a few advanced C++ projects before going and recommending it to others

also I don't know if you fully got the point. unordered_map is part of the C++ standard library. It's not C. The point was that C++ is much more messy

Last edited by MegaApuTurkUltra (May 22, 2019 05:41:11)

$(".box-head")[0].textContent = "committing AT crimes since $whenever"

bybb

MegaApuTurkUltra wrote:
ResExsention wrote:
snip
not to be rude, but it really sounds like you haven't written a whole lot of C++ yet. I'd advise you to fully familiarize yourself with the language and do at least a few advanced C++ projects before going and recommending it to others

This message is directed at every who doesn't use C++.

PLEASE DO NOT LEARN C++ UNTIL YOU ACTUALLY CAN PROGRAM (not just code)
As someone who has gone SmallBasic -> Visual Basic 2010 -> Python -> Java -> C++, I can definitely say that despite many similarities between C++ and Java, C++ is a whole other thing. Pointers are probably what you will really hate (I used to, am more familiar with them now).

Also remember, C++ isn't C with classes. Learn the C++17 spec and then you'll find things easier.

Game Over
You'll find me on @LastContinue from now on.

ResExsention

MegaApuTurkUltra wrote:
ResExsention wrote:
snip
not to be rude, but it really sounds like you haven't written a whole lot of C++ yet. I'd advise you to fully familiarize yourself with the language and do at least a few advanced C++ projects before going and recommending it to others

also I don't know if you fully got the point. unordered_map is part of the C++ standard library. It's not C. The point was that C++ is much more messy

Oh! I thought you were talking about C? I was taking some rough guesses, so it wasn't my best translation. I was trying to account for the discrepancies between C and C++.

Next time, please let me know on the language.

About your advanced projects suggestion. Again, I have done advanced projects before, but it was a while ago. I've since migrated to a different language and game development in Godot (better than Unity, in my opinion, and completely FOSS, unlike Unity), so it's been a while.

I would still recommend C++. It was actually the first programming language that I learned, and it was where I got introduced to all the concepts of programming.

Please forgive me for my previous statements as well about the messiness of code. It really depends on the programmer on how messy the code is, not the language. I personally like to keep my code neat, and all I've seen so far is messy C code so that statement was biased. It depends on the programmer, not the language.

bybb wrote:
MegaApuTurkUltra wrote:
ResExsention wrote:
snip
not to be rude, but it really sounds like you haven't written a whole lot of C++ yet. I'd advise you to fully familiarize yourself with the language and do at least a few advanced C++ projects before going and recommending it to others
This message is directed at every who doesn't use C++.

PLEASE DO NOT LEARN C++ UNTIL YOU ACTUALLY CAN PROGRAM (not just code)
As someone who has gone SmallBasic -> Visual Basic 2010 -> Python -> Java -> C++, I can definitely say that despite many similarities between C++ and Java, C++ is a whole other thing. Pointers are probably what you will really hate (I used to, am more familiar with them now).

Also remember, C++ isn't C with classes. Learn the C++17 spec and then you'll find things easier.

No, C++ is CwC. I've seen C++17 and it was really good, TBH.

Exactly. Well, I will have to contradict your statement on don't learn any language until you know how programming (in anything) works. I literally learned C++ many years ago when I was nine years old.

Pointers are useful, believe me.

Wow, you've had quite a lot of transitions between languages.

Infrequently active.

It feels weird to see how far we've come. I hope you're well, wherever you are!

bybb

ResExsention wrote:
No, C++ is CwC. I've seen C++17 and it was really good, TBH.

Exactly. Well, I will have to contradict your statement on don't learn any language until you know how programming (in anything) works. I literally learned C++ many years ago when I was nine years old.

Pointers are useful, believe me.

Wow, you've had quite a lot of transitions between languages.

“No, C++ is CwC” Never heard that term before, and it looks like a library

“I've seen C++17 before and it was really good”
What does this mean? You've “seen” C++17? It's a specification. It adds more to the standard library. Anyone using C++ should be using at least C++17 at the most modern specification they use the features of.

“I literally learned C++ many years ago when I was nine years old.”
No offense, but that's probably why you didn't realise unordered_map (or it's code) were C++. (removed by moderator - please don't ask for personal information)

C++ isn't the sort of language you'd want to start with first, especially at 9. If you had said 13/14 I could have believed it, but unless you're some kind of childhood genius (and from looking at how you handled Python code in another thread it didn't look like you had forgotten it, but rather you had learnt barely any and tried to do stuff with that as you were making very beginner mistakes, I started Python when I was 10/11. Haven't used it seriously for over two years, haven't forgotten any of it) I kind of doubt that you “learnt” C++, but rather knew enough to make things with it, and there's a key difference there.

“Pointers are useful, believe me.”
I know pointers are useful, that's the entire point I made in my post. Pointers responsible for so much that you need to know how to work with them to be able to do anything.

“Wow, you've had quite a lot of transitions between languages.”
And I am fluent in all of them. That's the key bit. I usually transition between working in C++, Javascript and Lua when making things.

By the way, have you got any C++ projects you can show? I'd like to see some of your code to see just how much modern C++ you're using.

Last edited by Paddle2See (May 23, 2019 09:24:17)

Game Over
You'll find me on @LastContinue from now on.

MegaApuTurkUltra

Look the fact that I gave @ResExsention a snippet of C++ code and they weren't able to recognize it as C++ is very telling…

$(".box-head")[0].textContent = "committing AT crimes since $whenever"

ResExsention

bybb wrote:
ResExsention wrote:
No, C++ is CwC. I've seen C++17 and it was really good, TBH.

Exactly. Well, I will have to contradict your statement on don't learn any language until you know how programming (in anything) works. I literally learned C++ many years ago when I was nine years old.

Pointers are useful, believe me.

Wow, you've had quite a lot of transitions between languages.
“No, C++ is CwC” Never heard that term before, and it looks like a library

“I've seen C++17 before and it was really good”
What does this mean? You've “seen” C++17? It's a specification. It adds more to the standard library. Anyone using C++ should be using at least C++17 at the most modern specification they use the features of.

“I literally learned C++ many years ago when I was nine years old.”
No offense, but that's probably why you didn't realise unordered_map (or it's code) were C++. (removed by moderator - please don't ask for personal information)
C++ isn't the sort of language you'd want to start with first, especially at 9. If you had said 13/14 I could have believed it, but unless you're some kind of childhood genius (and from looking at how you handled Python code in another thread it didn't look like you had forgotten it, but rather you had learnt barely any and tried to do stuff with that as you were making very beginner mistakes, I started Python when I was 10/11. Haven't used it seriously for over two years, haven't forgotten any of it) I kind of doubt that you “learnt” C++, but rather knew enough to make things with it, and there's a key difference there.

“Pointers are useful, believe me.”
I know pointers are useful, that's the entire point I made in my post. Pointers responsible for so much that you need to know how to work with them to be able to do anything.

“Wow, you've had quite a lot of transitions between languages.”
And I am fluent in all of them. That's the key bit. I usually transition between working in C++, Javascript and Lua when making things.

By the way, have you got any C++ projects you can show? I'd like to see some of your code to see just how much modern C++ you're using.

Lol. I generally don't mess with libraries that much. That's why I was unfamiliar with unordered map. I know map, and vector, and deque, but never heard of unordered map. Never had to use it, since map worked wonders for everything I have needed to do until now.

Yep, I've seen C++17. A couple more features. TBH, if I'm not using C++17 I'm using C++14.

“No, C++ is CwC” Never heard that term before, and it looks like a library

Acronym. I didn't feel like writing C with classes since I was in a rush. CwC seemed to work. Sorry about that. It wasn't supposed to mean anything special.

Yes, I learned it when I was 9. C++ is that easy. Then I transitioned to HTML and CSS, then Python, then Lua, then GDScript, the language used in Godot. I'm still fluent in quite a few of those languages (specifically C++ though I haven't reviewed it in a while, HTML, and GDScript).

MegaApuTurkUltra wrote:
Look the fact that I gave @ResExsention a snippet of C++ code and they weren't able to recognize it as C++ is very telling…

Again, please tell me the language. I have never needed to mess with unordered map, so yeah. Maybe you should give me the map library instead. I'm more familiar with it.

By the way, have you got any C++ projects you can show? I'd like to see some of your code to see just how much modern C++ you're using.

As I said, I haven't done C++ in a while since I'm more GDScript now. Then I switched computers a year ago and wiped my old computer. Sorry about that. I haven't done any major C++, the only thing I use CodeBlocks for now is looking at C++ source code.

But still, I wouldn't recommend starting with C. Not only could you confuse between the other versions of C or similar languages (Java, D, F#, etc), but I would say that C++ is a very fast language. That's why I didn't learn C. I was confusing between C++ and C and a tiny bit of C#, so I didn't think it was worth it to learn a language so similar to that I already know.

And what's up with throwing people into 3D modelling right away?

Last edited by Paddle2See (May 23, 2019 09:26:11)

Infrequently active.

It feels weird to see how far we've come. I hope you're well, wherever you are!

Discuss Scratch