Do all the things like ++ or -- rants, post your own rants, comment on others' rants and build your customized dev avatarSign Up
From the creators of devRant, Pipeless lets you power real-time personalized recommendations and activity feeds using a simple APILearn More
AleCx0426966148dbut no seriously, titties and small waists and nice legs, that is the dream man. OH AND people learning how to write proper C and C++ code thus not making dudes try to write new languages like Nim (which I like), Oding(which I like), Zig (which I also like) and V( let us get back to this sometime later shall we?)
Bit chichis and good languages go hand in hand (see what I did there?) and should be the main focus of this discussion.
and yes, I am still writing a VBScript implementation of a new modern VBScript alternative for old fuckers like me that liked writing classic ASP using VBScript for the web and would like more PHP-like features for the language.
ars1900147dAs long as the ass is fine, I'm fine with a washboard chest.
Rust sounds like a cool language.
Fast-Nop35781147dI don't use debuggers (or only like once per year at most) and IDEs either. Debuggers in particular are only useful if you need to figure out what your code is even doing. That ought to be an exceptionally rare situation, or else something is very wrong to begin with.
Also, typical memory errors will not show up in a debugger unless you feed the program with data or conditions that will make it crash. That in turn requires that you come up with such data and conditions.
But if you can do that, why not just taking that smart pill already when coding and making the program robust from the get-go?
That's what I do. Given the exponential curve of bugfix cost vs. project phase, one hour invested into robust coding spares ten hours of debugging. I code slowly and review my shit several times because I'm too lazy for debugging, and I'm also finished faster that way.
ostream2196147dWait so people who dislikes IDEs are bad programmers because they are not mindful of memory usage? IDEs are the perfect example of over-engineered piece of craps who are NOT mindful of their memory usage.
We've been trying to make programmers write better code for 70 years now. It doesn't work. Humans aren't perfect.
Sure there are some rockstars that can come close to perfect, but there are far too few of them to rely upon.
Esteban Kuber, one of the people working on the Rust compiler says this:
"There are no bad programmers, only insufficiently advanced compilers"
I subscribe to this wholeheartedly. The better the compiler, the more any developer can accomplish.
@ostream I never made mention of it, but since for whatever reason you decided to focus on that out of everything else I wrote I will go ahead and address the notion: If you work on a project larger than what the base generation of the project structure is, then useful features like proper intellisense, package manager support, environment support, debugging etc make a lot of sense.
People talk about memory hungry systems and bloat, then go on and install a trillion plugins on VS code or modify the heck of their emacs/vim environments.
@Geoxion This as a whole proves my point even more really. I am blaming people here, not languages.
But then, I will disagree with what Esteban Kuber wrote, years in the field seeing the worst Delphi, PHP, JS, Java, C#, VB(6, NET and Script) among a plethora of others has proven to me that people will be bad programmers, regardless of how much a compiler or interpreter error will attempt to assist them.
@Fast-Nop Multiple times have I told people, in particular when I was mentoring students or training people to stop messing up with a standard text editor if they can't spot their mistake and open it up in an IDE, one time I saw an inexperienced developer continuously forcing a Cpp program in notepad out of all text editors to compile using the command line.
Opened it up in VS, woooo lo and behold lil homie was trying to access a member of a pointer to a struct using . rather than ->, now, If I try and do this on any modern C++ compiler, an easy to read error message. So that is not too much of an issue, an IDE (heck even a Text editor like VS Code would point it out) would point it out as well.
all of this reinforces on my idea that it is more of a reflection of people being stupid rather than language fault.
Also, I did not say that the debugger allows you to debug memory issues, but i believe it does let you see where things are and understand foreign codebases
@AleCx04 well, but if the problem is people, then what's the solution?
Since the dawn of programming we've relied on people not making mistakes. But no matter how good they are, everybody makes a mistake eventually.
So we've tried simply making fewer mistakes and so far that hasn't worked.
Now what Rust does is minimize the area where mistakes can be made. If you assume that a person makes a % amount of mistakes per loc, then when only 10% of lines even allow for mistakes, you'd expect only 10% of mistakes left in the code.
It can't prevent you from having bad or changing requirements though.
@Geoxion homie I get you, but I don't think you get me. I am not chastising rust or saying that it is a bad language, I praised it multiple times in my post.
My point is, that if the language was made to prevent people from doing stupid shit it does not mean that the other language is bad, again, reiterating the end of my post, I state that articles calling it the death of c++ because we know have rust should be taking a look at the language through a different point of view not "I can't do stupid here! this better!"
Fast-Nop35781147d@AleCx04 Well, plain Notepad wouldn't be my thing because I rely on coloured syntax highlighting for visual navigation, but Notepad++ already offers that.
Using a debugger for figuring out a foreign codebase is at best a temporary crutch that one should leave behind as fast as possible. If the root cause it total spaghetti, leave the codebase, the job, or the company behind.
One big thing that a debugger fails at is non-reproducible bugs. That's why "read the source, Luke" is an important skill. No debugger or IDE can replace that.
@AleCx04 Ok, then maybe I can explain why someone might argue that a language can better than another even when they're functionally the same.
Lang A and B are almost equal, even syntactically.
A let's the user do whatever.
B makes sure the user makes fewer mistakes through compile checks.
Now, both A and B have a library ecosystem that equally smart people worked on.
Which ecosystem will be buggier?
It's A of course.
So, because the average code quality of B will be higher, people will argue that B is a better language.
the gentleman raises an interest topic indeed! Very well very well let us look into this.
In terms of these two languages, consider that most talks, documentation, books etc do not necessarily talk about code quality, but safety. the main selling point of R is safety, I will give the gentleman that safety is around the area of quality.
The gentleman needs now to consider this, Python is safe, can one not write shitty code in Python? What about Java, C# or Go? or PHP? these languages are safe.
Rust removed unsafety, amazingly well so, it did not, however, took away the power that people have of writing bad code.
The gentleman has the floor.
shivayl1506146dGold, THIS IS GOLD
mundo035394146dYou got me at what pendejos and putos do with C++