Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[kytuzian]

Well you obviously don't start with C++ or whatever. Python/scripting language is probably best.

Also, for some reason I can't really relate to its syntax >.> I guess I need to find an interpreter that actually works, first.

This is the kind of innocent looking but extremely destructive and misleading comment that really should be avoided. Please, please, PLEASE avoid them... If anything, it's C++ that has that problem with its OS-dependent standards and compilers. Good luck cross-compiling anything at all in C++! It requires pre-processors, emulated linux environments, multiple individually downloaded, configured and linked library versions... In Python you copy the source file and double-click it.... there is ONE official interpreter, available for all major platforms, and I've yet to hear about or experience any cross-platform issues.

You've made as many comments about C++ like that as he has made comments about Python. Besides, I don't understand why you (in general) think that speed is unimportant. I get how the whole roguelike thing works, but even so, it might matter at some point.

The only times I use Python is when I want to write something quickly, like on my phone (and that I only found a free Python app). I realize that is exactly what some people have been saying, but I use it because I want to write quickly, not because I want it to run quickly.

And finally, C++ isn't really that difficult to use.

EDIT: By the way, Python was made with C.

[Anvilfolk]

Isn't XNA "the big thing" for C#? They're both Microsoft technologies, so both should work just fine, no?

A blog post from developer Promit Roy earlier this week apparently detailed Microsoft's plans to fully retire the XNA Game Studio tools on April 1, 2014...

"XNA Game Studio remains a supported toolset for developing games for Xbox 360, Windows and Windows Phone," said the representative. "Many developers have found financial success creating Xbox LIVE Indie Games using XNA. However, there are no plans for future versions of the XNA product."

Well, shoot! I was actually pondering foregoing multi-platform because XNA seemed to be "the thing", but I guess not anymore

Well you obviously don't start with C++ or whatever. Python/scripting language is probably best.

SNIP

You've made as many comments about C++ like that as he has made comments about Python. Besides, I don't understand why you (in general) think that speed is unimportant. I get how the whole roguelike thing works, but even so, it might matter at some point.

Sorry if I didn't make my point clear. What I meant to say is that the comment made apparent that there are serious problems with getting Python to work, when it's a matter of running the official installer and that's that. It's the kind of comment a newcomer would look at and say "interpreter? What's that? And some don't work? Ooh, better not get into THAT" - I find it really hurts the possibility of Python being used, and it's entirely ironic that it's C++ that has those problems and not Python at all. I might've gone off my top a bit... I apologise

Regarding speed: it comes down to who we are trying to advise. Python has a cleaner syntax and an easier development environment to work with in general. Like you said: it's about writing (or learning) quickly, not about how fast it goes. Let that be a concern for further down the line, when they've figured out whether they like programming and whether they need to worry about it

By the way, the first C compiler was made with assembly. Should we all use that instead?


But to get a little bit further back on topic... is everyone using curses for roguelike development? I've been toying with PyGame a bit and find it's perfectly OK for tile-based games. I still feel it's far too low-level, but such is life

[kytuzian]

By the way, the first C compiler was made with assembly. Should we all use that instead?

Yeah, saw that one coming. I agree with everything else, but that a little more extreme. If speed is absolutely critical, then yes. But for most things, that too extreme.

This is Assembly for a random function in C++

Spoiler (click to show/hide)

004282E4   push   %ebp
004282E5   mov    %esp,%ebp
004282E7   push   %edi
004282E8   push   %esi
004282E9   push   %ebx
004282EA   sub    $0xcc,%esp
004282F0   movl   $0x437cfc,-0x74(%ebp)
004282F7   movl   $0x4c1f4c,-0x70(%ebp)
004282FE   lea    -0x6c(%ebp),%eax
00428301   lea    -0x18(%ebp),%edx
00428304   mov    %edx,(%eax)
00428306   mov    $0x428457,%edx
0042830B   mov    %edx,0x4(%eax)
0042830E   mov    %esp,0x8(%eax)
00428311   lea    -0x8c(%ebp),%eax
00428317   mov    %eax,(%esp)
0042831A   call   0x449b70 <_Unwind_SjLj_Register>
0042831F   lea    -0x4c(%ebp),%eax
00428322   mov    %eax,(%esp)
00428325   movl   $0xffffffff,-0x88(%ebp)
0042832F   call   0x458e58 <animation>
00428334   lea    -0x54(%ebp),%eax
00428337   mov    %eax,(%esp)
0042833A   call   0x4534e4 <image>
0042833F   movl   $0x0,-0x38(%ebp)
00428346   mov    0x14(%ebp),%eax
00428349   mov    %eax,-0x40(%ebp)
0042834C   movl   $0x0,-0x3c(%ebp)
00428353   movl   $0x0,-0x1c(%ebp)
0042835A   jmp    0x428665 <object::load_animation(std::string, int, int)+897>
0042835F   lea    -0x2d(%ebp),%eax
00428362   mov    %eax,(%esp)
00428365   call   0x47d490 <std::allocator<char>::allocator()>
0042836A   lea    -0x24(%ebp),%eax
0042836D   mov    -0x1c(%ebp),%edx
00428370   mov    %edx,0x4(%esp)
00428374   mov    %eax,(%esp)
00428377   movl   $0x6,-0x88(%ebp)
00428381   call   0x42fcb3 <str(int)>
00428386   sub    $0x4,%esp
00428389   lea    -0x20(%ebp),%eax
0042838C   movl   $0x4c68ca,0x8(%esp)
00428394   mov    0xc(%ebp),%edx
00428397   mov    %edx,0x4(%esp)
0042839B   mov    %eax,(%esp)
0042839E   movl   $0x5,-0x88(%ebp)
004283A8   call   0x4bfc28 <std::basic_string<char, std::char_traits<char>, std::allocator<char> > std::operator+<char, std::char_traits<char>, std::allocator<char> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, char const*)>
004283AD   sub    $0x4,%esp
004283B0   lea    -0x28(%ebp),%eax
004283B3   lea    -0x24(%ebp),%edx
004283B6   mov    %edx,0x8(%esp)
004283BA   lea    -0x20(%ebp),%edx
004283BD   mov    %edx,0x4(%esp)
004283C1   mov    %eax,(%esp)
004283C4   movl   $0x4,-0x88(%ebp)
004283CE   call   0x4bfce4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> > std::operator+<char, std::char_traits<char>, std::allocator<char> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>
004283D3   sub    $0x4,%esp
004283D6   lea    -0x2c(%ebp),%eax
004283D9   movl   $0x4c68cc,0x8(%esp)
004283E1   lea    -0x28(%ebp),%edx
004283E4   mov    %edx,0x4(%esp)
004283E8   mov    %eax,(%esp)
004283EB   movl   $0x3,-0x88(%ebp)
004283F5   call   0x4bfc28 <std::basic_string<char, std::char_traits<char>, std::allocator<char> > std::operator+<char, std::char_traits<char>, std::allocator<char> >(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, char const*)>
004283FA   sub    $0x4,%esp
004283FD   lea    -0x2c(%ebp),%eax
00428400   mov    %eax,(%esp)
00428403   movl   $0x2,-0x88(%ebp)
0042840D   call   0x45a690 <std::string::c_str() const>
00428412   lea    -0x2d(%ebp),%edx
00428415   mov    %edx,0x8(%esp)
00428419   mov    %eax,0x4(%esp)
0042841D   lea    -0x34(%ebp),%eax
00428420   mov    %eax,(%esp)
00428423   call   0x487f24 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(char const*, std::allocator<char> const&)>
00428428   lea    -0x34(%ebp),%eax
0042842B   mov    %eax,(%esp)
0042842E   movl   $0x1,-0x88(%ebp)
00428438   call   0x4301a4 <load_image(std::string)>
0042843D   mov    %eax,-0x54(%ebp)
00428440   lea    -0x34(%ebp),%eax
00428443   mov    %eax,(%esp)
00428446   movl   $0x2,-0x88(%ebp)
00428450   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
00428455   jmp    0x4284ca <object::load_animation(std::string, int, int)+486>
00428457   lea    0x18(%ebp),%ebp
0042845A   mov    -0x88(%ebp),%ecx
00428460   mov    -0x84(%ebp),%eax
00428466   mov    -0x80(%ebp),%edx
00428469   cmp    $0x1,%ecx
0042846C   je     0x4284e1 <object::load_animation(std::string, int, int)+509>
0042846E   cmp    $0x2,%ecx
00428471   je     0x428527 <object::load_animation(std::string, int, int)+579>
00428477   cmp    $0x3,%ecx
0042847A   je     0x42856d <object::load_animation(std::string, int, int)+649>
00428480   cmp    $0x4,%ecx
00428483   je     0x4285b3 <object::load_animation(std::string, int, int)+719>
00428489   cmp    $0x5,%ecx
0042848C   je     0x42863d <object::load_animation(std::string, int, int)+857>
00428492   cmp    $0x6,%ecx
00428495   je     0x4286c3 <object::load_animation(std::string, int, int)+991>
0042849B   mov    %edx,-0xc0(%ebp)
004284A1   mov    %eax,-0xc4(%ebp)
004284A7   lea    -0x34(%ebp),%eax
004284AA   mov    %eax,(%esp)
004284AD   movl   $0x0,-0x88(%ebp)
004284B7   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
004284BC   mov    -0xc4(%ebp),%eax
004284C2   mov    -0xc0(%ebp),%edx
004284C8   jmp    0x4284e1 <object::load_animation(std::string, int, int)+509>
004284CA   lea    -0x2c(%ebp),%eax
004284CD   mov    %eax,(%esp)
004284D0   movl   $0x3,-0x88(%ebp)
004284DA   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
004284DF   jmp    0x428510 <object::load_animation(std::string, int, int)+556>
004284E1   mov    %edx,-0xb8(%ebp)
004284E7   mov    %eax,-0xbc(%ebp)
004284ED   lea    -0x2c(%ebp),%eax
004284F0   mov    %eax,(%esp)
004284F3   movl   $0x0,-0x88(%ebp)
004284FD   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
00428502   mov    -0xbc(%ebp),%eax
00428508   mov    -0xb8(%ebp),%edx
0042850E   jmp    0x428527 <object::load_animation(std::string, int, int)+579>
00428510   lea    -0x28(%ebp),%eax
00428513   mov    %eax,(%esp)
00428516   movl   $0x4,-0x88(%ebp)
00428520   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
00428525   jmp    0x428556 <object::load_animation(std::string, int, int)+626>
00428527   mov    %edx,-0xb0(%ebp)
0042852D   mov    %eax,-0xb4(%ebp)
00428533   lea    -0x28(%ebp),%eax
00428536   mov    %eax,(%esp)
00428539   movl   $0x0,-0x88(%ebp)
00428543   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
00428548   mov    -0xb4(%ebp),%eax
0042854E   mov    -0xb0(%ebp),%edx
00428554   jmp    0x42856d <object::load_animation(std::string, int, int)+649>
00428556   lea    -0x20(%ebp),%eax
00428559   mov    %eax,(%esp)
0042855C   movl   $0x5,-0x88(%ebp)
00428566   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
0042856B   jmp    0x42859c <object::load_animation(std::string, int, int)+696>
0042856D   mov    %edx,-0xa8(%ebp)
00428573   mov    %eax,-0xac(%ebp)
00428579   lea    -0x20(%ebp),%eax
0042857C   mov    %eax,(%esp)
0042857F   movl   $0x0,-0x88(%ebp)
00428589   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
0042858E   mov    -0xac(%ebp),%eax
00428594   mov    -0xa8(%ebp),%edx
0042859A   jmp    0x4285b3 <object::load_animation(std::string, int, int)+719>
0042859C   lea    -0x24(%ebp),%eax
0042859F   mov    %eax,(%esp)
004285A2   movl   $0x6,-0x88(%ebp)
004285AC   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
004285B1   jmp    0x4285e2 <object::load_animation(std::string, int, int)+766>
004285B3   mov    %edx,-0xa0(%ebp)
004285B9   mov    %eax,-0xa4(%ebp)
004285BF   lea    -0x24(%ebp),%eax
004285C2   mov    %eax,(%esp)
004285C5   movl   $0x0,-0x88(%ebp)
004285CF   call   0x4886e4 <std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()>
004285D4   mov    -0xa4(%ebp),%eax
004285DA   mov    -0xa0(%ebp),%edx
004285E0   jmp    0x42863d <object::load_animation(std::string, int, int)+857>
004285E2   lea    -0x2d(%ebp),%eax
004285E5   mov    %eax,(%esp)
004285E8   call   0x47d4a8 <std::allocator<char>::~allocator()>
004285ED   mov    -0x54(%ebp),%eax
004285F0   mov    0xc(%eax),%eax
004285F3   movzwl %ax,%ecx
004285F6   mov    -0x54(%ebp),%eax
004285F9   mov    0x8(%eax),%eax
004285FC   movzwl %ax,%edx
004285FF   mov    -0x54(%ebp),%eax
00428602   mov    %ecx,0x8(%esp)
00428606   mov    %edx,0x4(%esp)
0042860A   mov    %eax,(%esp)
0042860D   movl   $0x7,-0x88(%ebp)
00428617   call   0x435dde <ScaleSurface(SDL_Surface*, unsigned short, unsigned short)>
0042861C   mov    %eax,-0x50(%ebp)
0042861F   lea    -0x54(%ebp),%eax
00428622   mov    %eax,0x4(%esp)
00428626   lea    -0x4c(%ebp),%eax
00428629   mov    %eax,(%esp)
0042862C   movl   $0x7,-0x88(%ebp)
00428636   call   0x4ae90c <std::vector<image, std::allocator<image> >::push_back(image const&)>
0042863B   jmp    0x428662 <object::load_animation(std::string, int, int)+894>
0042863D   mov    %edx,-0x98(%ebp)
00428643   mov    %eax,-0x9c(%ebp)
00428649   lea    -0x2d(%ebp),%eax
0042864C   mov    %eax,(%esp)
0042864F   call   0x47d4a8 <std::allocator<char>::~allocator()>
00428654   mov    -0x9c(%ebp),%eax
0042865A   mov    -0x98(%ebp),%edx
00428660   jmp    0x4286c3 <object::load_animation(std::string, int, int)+991>
00428662   incl   -0x1c(%ebp)
00428665   mov    -0x1c(%ebp),%eax
00428668   cmp    0x10(%ebp),%eax
0042866B   setl   %al
0042866E   test   %al,%al
00428670   jne    0x42835f <object::load_animation(std::string, int, int)+123>
00428676   mov    0x8(%ebp),%eax
00428679   lea    0x30(%eax),%edx
0042867C   lea    -0x4c(%ebp),%eax
0042867F   mov    %eax,0x4(%esp)
00428683   mov    %edx,(%esp)
00428686   movl   $0x7,-0x88(%ebp)
00428690   call   0x4b3ad0 <std::vector<animation, std::allocator<animation> >::push_back(animation const&)>
00428695   lea    -0x4c(%ebp),%eax
00428698   mov    %eax,(%esp)
0042869B   movl   $0xffffffff,-0x88(%ebp)
004286A5   call   0x458e6c <~animation>
004286AA   lea    -0x8c(%ebp),%eax
004286B0   mov    %eax,(%esp)
004286B3   call   0x449b1c <_Unwind_SjLj_Unregister>
004286B8   lea    -0xc(%ebp),%esp
004286BB   add    $0x0,%esp
004286BE   pop    %ebx
004286BF   pop    %esi
004286C0   pop    %edi
004286C1   leave
004286C2   ret
004286C3   mov    %edx,-0x90(%ebp)
004286C9   mov    %eax,-0x94(%ebp)
004286CF   lea    -0x4c(%ebp),%eax
004286D2   mov    %eax,(%esp)
004286D5   movl   $0x0,-0x88(%ebp)
004286DF   call   0x458e6c <~animation>
004286E4   mov    -0x94(%ebp),%eax
004286EA   mov    -0x90(%ebp),%edx
004286F0   mov    %eax,(%esp)
004286F3   movl   $0xffffffff,-0x88(%ebp)
004286FD   call   0x449e10 <_Unwind_SjLj_Resume>

This is the original (I know I'm not amazing at this or anything, but that's not the point):

Spoiler (click to show/hide)

void object::load_animation(string file, int frames, int speed)
{
    animation new_animation(speed, 0, 0); //Set speed to specified speed, current frame to 0, and counter to 0

    image loaded;
    loaded.scaled = NULL;

    //load images
    for (int i = 0; i < frames; i++)
    {
        loaded.original = load_image((file + "_" + str(i) + ".png").c_str());

        new_animation.images.push_back(loaded);
    }

    //add animation to object's animation list
    this->animations.push_back(new_animation);
}

This is my guess of what it would look like in Python (Note: I've never done anything like this in Python):

Spoiler (click to show/hide)

def load_animation(self, file, frames, speed):
    new_animation = animation(speed, 0, 0)

    loaded = image(NULL, NULL)

    for i in range(0, frames):
        loaded.original = load_image((file + "_" + str(i) + ".png"))
        new_animation.images.append(loaded)

    self.animations.append(new_animation)

Pretty darn similar.

[alexandertnt]

And finally, C++ isn't really that difficult to use.

EDIT: By the way, Python was made with C.

C++ is certainly alot harder than most languages to use, often unnecessarily so. I would not want to deal with its issues (especially its error messages) when there are simply superior languages out there for a given task to make development easier.

C I don't have much of an issue with (except as a beginners language. C was simply not designed as a beginners language.). It's low-level, fast, portable etc. It's a system language and programming a language with C makes plenty of sense. Also there are Python interperators in other languages available (Including Python itself, its CPython that is made in C).

Actually, I think C++ has some nifty features. The stream operator (<<), compile-time templates (that don't suck, like Java generics...), C++11 initializer lists (squeeeee), language-level support for the = operator and copy constructors, great compiler and debugger support. C++11 also modernizes the language a lot (although, for backwards compatibility, it also introduces a lot of its own complications).

The "stream" operator is just an overloaded bitshift operator.

Java's generics do indeed suck, and C++'s templates work pretty well, I will give it that. But many other languages have good template/generic support.

Initializer lists have been in many languages well before C++11 (Here is a C# example).

the = operator is nice for allowing fine control, but is often a stumbling point when new programmers start copying their super-long arrays all over the place (and passing by value rather than reference on non-mutating functions. In loops  ).

The obscurated error messages the compiler give are often difficult to understand. Many other languages offer much nicer debugging, some even allow you to modify code while the program is running.

C++11 does alot to modernize the language (lambda expressions + <algorithm> ftw), adding in some much-needed stuff and is a step in the right direction, but many more steps IMO are needed (still no reflection, garbage collection etc).

def load_animation(self, file, frames, speed):
    new_animation = animation(speed, 0, 0)

    loaded = image(NULL, NULL)

    for i in range(0, frames):
        loaded.original = load_image((file + "_" + str(i) + ".png"))
        new_animation.images.append(loaded)

    self.animations.append(new_animation)

That just fill a list full of the same, identical image instance. (when you add an object in Python, you add a reference to it not a copy).

A trivial example will look similar. If you write a whole program C-style, Python programmers will hang you. This study, for example compares C/C++ and scripting languages (and java) for a string searching/processing program and the length of the scripting languages came up much shorter in length.

Now do some callback stuff with functions of object instances and compare the two

[Robosaur]

IMHO they need to make a pokemon roguelike that plays something like the battle pyramid in pokemon emerald.

Alternatively, Froguer. The frogger roguelike.

[Skyrunner]

Spoiler: Incensed rebuttal (click to show/hide)

Well you obviously don't start with C++ or whatever. Python/scripting language is probably best.

Also, for some reason I can't really relate to its syntax >.> I guess I need to find an interpreter that actually works, first.

This is the kind of innocent looking but extremely destructive and misleading comment that really should be avoided. Please, please, PLEASE avoid them... If anything, it's C++ that has that problem with its OS-dependent standards and compilers. Good luck cross-compiling anything at all in C++! It requires pre-processors, emulated linux environments, multiple individually downloaded, configured and linked library versions... In Python you copy the source file and double-click it.... there is ONE official interpreter, available for all major platforms, and I've yet to hear about or experience any cross-platform issues.

Are you implying that I posted that on purpose? That I, with less-than-savory thoughts in mind?
I was just relating what I experienced. I downloaded a Python IDE, and the Python interpreter. I pasted the tutorial code and pressed run. I got hit with an incomprehensible erot message. That's it. :/ To me, Python wasn't kind or friendly. So I decided to learn it another day, especially since I don't need Python for what I'm doing right now. Maybe my shortened post seemed like a troll, but I assure you that branding me as one immediately, considering me to be an advocate of the horrible language that must be killed off as soon as possible, didn't help anything.

Now, do note that I've started with C++ and still use it after a year, so I probably am biased. Howver, I never said that C++ is the holy grail of programming. I did not say everyon should learn C++ and don't evn look at python, which is what you seemto be implying towards C++. All I did was comment that C++ is superior to any interpreted language on terms of speed. I wouldn't offer C++ to a beginner myself, even though it's what I learned with. :/

On the topic of libraries, I use libtcod + C++. Though the library is functional, from what I hear, instead of oo, it has fast methods and mostly intuitive things, though the input system of SDL is better, and the draw rectangle function is as counterintuitive as you can get. :s And please don't bash me that C++ is the worst choice I could make for a roguelike, because in my computation heavy plan it is the best one I could choose, other than C#.

Also, she.

I use libtcod. Full RGB support makes it a good choice to make pretty games, and it supports tiles a la DF, with pictures moving around.

[GlyphGryph]

Here's the thing about speed, and using a language like C++ for that reason.

Your language is far less likely to be your bottleneck than your crappy code and algorithms.

Just... as a general rule. Heh. Hell, 99.99% of programmers would probably get slower code out of assembly than they would out of C++, because the language requires so much more of the programmer to use it efficiently. A python script you actually run isn't being interpreted anymore than C++ is anyway, since it's all in bytecode, and if you precompile it you skip all the interpreter load time stuff. Anyone know what the actual speed difference is between an average compiled C++ and Python program?

Also Sky, like I said, you should really eventually use a Lisp variant like Scheme. You'll learn a lot! You don't really lose out by skipping Python. It's a nice language, but it's not terrible special.

[Skyrunner]

There was a graph above there somewhere, and it said Shedskin Python(compiled) was only four times(twice? forgot the exact number...) as slow as C on average, while interpreted Python took one hundred times as much time as C xD

[Mephisto]

This is the one thing I hate about the computer science field. It's all e-arguments about which language is better and selectively choosing which facts to support.

Since we're going off of this set of benchmarks, I could say that Python is only 1.4x as slow. I would hardly call sudoku solvers and counting insane numbers of strings "typical programs."

If a language works for you, use it.

[Absolute Niro]

IMHO they need to make a pokemon roguelike that plays something like the battle pyramid in pokemon emerald.

Alternatively, Froguer. The frogger roguelike.

The Pokemon Mystery Dungeon games are roguelikes, I believe. At least they play very similarly to roguelikes, I'm sure lots of people would disagree.

[alexandertnt]

Your language is far less likely to be your bottleneck than your crappy code and algorithms.

Absolutely.
With some languages, however, it is easier to accidently write inefficient code. Take, for example C++ and people's tendancy to pass everything by value.

I pasted the tutorial code and pressed run. I got hit with an incomprehensible erot message.

incomprehensible error messages in python doesnt sound right. Can I see this error message (mostly out of curiosity)?

This is the one thing I hate about the computer science field. It's all e-arguments about which language is better and selectively choosing which facts to support.

Since we're going off of this set of benchmarks, I could say that Python is only 1.4x as slow. I would hardly call sudoku solvers and counting insane numbers of strings "typical programs."

If a language works for you, use it.

Languages have their use in certain situations (try writing a system driver in Python ). I posted some empirical studies that is not just "e-arguments" or selectively chosen facts.

I would not claim that a language is simply superior entirely and ignore flaws and I do not believe that I have been "choosing which facts" to support. I also mentioned in an earlier post that if someone has been programming in language X, they will probably continue to do so and do a better job than programming in language Y.

Most of my arguments have been from the viewpoint of learning programming, and a particular opposition to learning C/C++ first, or "moving onto" C/C++ if you did not intend to use the features or the perks unique to that language (but had to deal with all its issues as previously mentioned). If you do not intend use the perks of C/C++, why move onto it? There is a strong belief that C++ is "the" language to learn (hell, thats why I learnt it) despite the fact that there is not much basis in reality behind this (there can be depending on why you want to learn it, but my opposition is to it being "the" language).

The discussion over the languages has been a fair and reasonable one. If you want to identify any issues with any of my arguments, I will be happy to fix, or rescind then if they are faulty and im sure others would do the same.

At least they play very similarly to roguelikes, I'm sure lots of people would disagree.

They do play very much like roguelikes.

[Mephisto]

The discussion over the languages has been a fair and reasonable one. If you want to identify any issues with any of my arguments, I will be happy to fix, or rescind then if they are faulty and im sure others would do the same.

That was not directed toward you. Apologies.

[Anvilfolk]

Let me start with an apology. I didn't mean to imply you did those comments with some secret and dark ulterior motives, Skyrunner (you spawn of Morgul, you!). Re-reading my post, it definitely looks like it, so I'm sorry. What I meant is that independently of your motives, it's still very damaging to a beginner's perception of Python, but most of all, I feel it's inaccurate

I am very surprised that happened to you in Python. I've been toying and re-learning it for - oh - about 8 years now, using multiple sources, and have never had those problems. If it's recent, it might've been that Python 3.x was made so as not to be backwards compatible in certain instances from Python 2.x (minor things like print("Hello world.") instead of print "Hello world"). I'll definitely agree that this is adding confusion... kind of like the one generated by different C/C++ standards

From my experiences of using C++, Java and Python (and ocaml, javascript, php, actionscript, etc) rather intensively at different times, I am still going to claim equally proficient people are going to develop faster in Python than in Java, and faster in Java than in Python. And for learning, I believe this is THE critical point. I guess I can't stress this enough: if you're learning, screw performance

Heck, I hear it's not that hard to do most things in Python and outsource the CPU-intensive stuff to C++ code

Also, what GlyphGryph said.


And finally, I haven't really tried libtcod, but I've heard some less than fantastic comments about it from Lord Dullard who is doing Cult. I also think what Toady did was to use some graphics library and just draw characters instead of actual graphics. That gives you a little more flexibility, at the expense of "ugh, graphics libraries..."

[Skyrunner]

I wouldn't ever say that C++ is not only the beginner's language of choice, nor would I ever say that Python isn't useful for pretty much most things.

What I'm doing right now with C++ is create a calculations-heavy simulation (to hopefully later plug into a roguelike front-end ), and if I'm going to do the calculations in embedded C++ and do the rest in Python, why not do it in C++ (which I'm pretty proficient at, at least from what I think) instead of trying to learn a bunch of things at once while also having to use C++ anyways... :/ Also, from a quick search long ago, I think it was C that had native embeddedness, and C++ needed some sort of add-on.

Also, I do think developing speed is hands-down Python over C++ after a certain time of experience in both. I just don't have the Python experience to justify it. :c

[Anvilfolk]

I guess we agreed all along then What kind of simulation are you doing?

And if you ever do get time, please give it a go! It's not hard to get into at all - you can still program C/C++ style, but then make use of all the awesome shortcuts it gives you (that you can learn bit by bit).

I've been toying with the idea of doing a serious collaboration with people from B12, since so many people are off doing their own projects and sometimes motivation flags. By serious collaboration I mean we would "skype-meet" at least once a week to discuss, have fun and work together. Hasn't it been tried before?