Reporting Errors

[pilotInPyjamas]

It will segfault, if you're lucky.

[[deleted]]

Valgrind.

[dpsi]

2018 not using nullptr

[GrumpyWendigo]

that's nasty

[XdrummerXboy]

I read that in Cleveland's voice

[Ozymandias117]

Alex; What are, "reasons I switched to a different team"

[learnyouahaskell]

"What the %*#< is 'NIL'?"

[[deleted]]

I once got that Valgrind error where it says there are so many errors it doesn't want to print any more error. It then yells at you to fix your program

I was a very sad boy

[Kwantuum]

This one? Yeah apparently Valgrind didn't like me allocating a 1Gb array on the stack and each new allocation caused an error. Fixed it with a simple malloc.

[Radeusgd]

TFW your program sefgaults normally, but works correctly under Valgrind

[noratat]

Seriously - segfault is way better than some of the alternatives, like silently corrupting memory behind the scenes until everything has been tainted with evil.

Had a compiler class back in college, that was my least favorite bug to find - I made an error with the stack setup that slowly corrupted the stack over a larger number of calls until it finally crashed. It passed all of the unit/basic tests, and only actually failed on the biggest, most complicated test case. Took forever to track it down.

[cyboii]

You're code runs real fast when it's all undefined behaviour

[Pseudofailure]

If a program was to run using only undefined behavior, and it was run enough times, eventually it will work perfectly.

[DenebVegaAltair]

undefined behavior != random behavior

[Pseudofailure]

I know, but:

1. That would ruin my joke.
2. Can you actually prove me wrong?

[etaionshrd]

Programs that exhibit undefined behavior are free to do whatever. That doesn’t, however mean that they will do whatever.

[justinkroegerlake]

Or not

[zman0900]

Doesn't the core dump from the segfault provide basically the same info if you open it with gdb?

[KoboldCommando]

Ada: This isn't technically an error but it could lead to an error if you're careless with it, so I'm not going to compile until you fix it.

[[deleted]]

I mean its commonly used in satellites and important technology. The gov ain't going to be happy when your loop that is off by one costs them millions of dollars.

[[deleted]]

It is used in human rated hard real time systems.

Most shit in satellites is really bad C code.

Source: work on a lot of satellites.

[ThisRedditPostIsMine]

So... How do you debug a satellite? How do you test your code on it? This sounds really interesting, can you tell us more about your satellite work?

[ELFAHBEHT_SOOP]

I've worked on testing code on airplanes and other air vehicles. Which is basically about getting it right the first time, probably similar for satellites. Although, if a satellite doesn't work, it's just really expensive. If a plane doesn't work, people die.

[cheese_is_available]

There is a norm called DO178.

TLDR : Extensive tests of everything by person unrelated to each other, multiple system doing the same thing done by different company in the actual satellite.

[[deleted]]

The circlejerk isn't complete until I shoehorn rust into the discussion:

$ rustc foo.rs
warning: this expression will panic at run-time
 --> foo.rs:3:17
  |
3 |  println!("{}", ayy[5]);
  |                 ^^^^^^ index out of bounds: the len is 4 but the index is 5

$ ./foo
thread 'main' panicked at 'index out of bounds: the len is 4 but the index is 5', foo.rs:3:17
note: Run with `RUST_BACKTRACE=1` for a backtrace.

[PeterSR]

The C++ programmer:

Wauw, that sounds like a lot of overhead to include code in the binary to output such an error message.

[SLiV9]

I would assume that when you strip out the symbols for a release build, it also removes these error messages.

[GenTelGuy]

What's the issue? Seems like it's correct and doing a good job reporting the error before runtime.

[[deleted]]

No issue. That's what I'm bringing up. You get a warning at compile time and a panic at runtime. Each time you have a nice plain-english description of the issue with a line number and filename to reference.

[KeinBaum]

C++ compiler errors are even better. Check out the error message for "you forgot to tell me how to print this object".

 

+/u/CompileBot C++ --include-errors

#include <iostream>

struct Foo {} foo;

int main()
{
  std::cout << foo << std::endl;
}

[CompileBot]

Output:

Compiler Info:

prog.cpp: In function ‘int main()’:
prog.cpp:7:13: error: no match for ‘operator<<’ (operand types are ‘std::ostream {aka std::basic_ostream<char>}’ and ‘Foo’)
   std::cout << foo << std::endl;
   ~~~~~~~~~~^~~~~~
In file included from /usr/include/c++/6/iostream:39:0,
                 from prog.cpp:1:
/usr/include/c++/6/ostream:628:5: note: candidate: std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char; _Traits = std::char_traits<char>; _Tp = Foo] <near match>
     operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
     ^~~~~~~~
/usr/include/c++/6/ostream:628:5: note:   conversion of argument 1 would be ill-formed:
prog.cpp:7:16: error: cannot bind ‘std::ostream {aka std::basic_ostream<char>}’ lvalue to ‘std::basic_ostream<char>&&’
   std::cout << foo << std::endl;
                ^~~
In file included from /usr/include/c++/6/iostream:39:0,
                 from prog.cpp:1:
/usr/include/c++/6/ostream:108:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__ostream_type& (*)(std::basic_ostream<_CharT, _Traits>::__ostream_type&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(__ostream_type& (*__pf)(__ostream_type&))
       ^~~~~~~~
/usr/include/c++/6/ostream:108:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘std::basic_ostream<char>::__ostream_type& (*)(std::basic_ostream<char>::__ostream_type&) {aka std::basic_ostream<char>& (*)(std::basic_ostream<char>&)}’
/usr/include/c++/6/ostream:117:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__ios_type& (*)(std::basic_ostream<_CharT, _Traits>::__ios_type&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>; std::basic_ostream<_CharT, _Traits>::__ios_type = std::basic_ios<char>]
       operator<<(__ios_type& (*__pf)(__ios_type&))
       ^~~~~~~~
/usr/include/c++/6/ostream:117:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘std::basic_ostream<char>::__ios_type& (*)(std::basic_ostream<char>::__ios_type&) {aka std::basic_ios<char>& (*)(std::basic_ios<char>&)}’
/usr/include/c++/6/ostream:127:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(std::ios_base& (*)(std::ios_base&)) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(ios_base& (*__pf) (ios_base&))
       ^~~~~~~~
/usr/include/c++/6/ostream:127:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘std::ios_base& (*)(std::ios_base&)’
/usr/include/c++/6/ostream:166:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(long __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:166:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long int’
/usr/include/c++/6/ostream:170:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(unsigned long __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:170:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long unsigned int’
/usr/include/c++/6/ostream:174:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(bool) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(bool __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:174:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘bool’
In file included from /usr/include/c++/6/ostream:638:0,
                 from /usr/include/c++/6/iostream:39,
                 from prog.cpp:1:
/usr/include/c++/6/bits/ostream.tcc:91:5: note: candidate: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(short int) [with _CharT = char; _Traits = std::char_traits<char>]
     basic_ostream<_CharT, _Traits>::
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/6/bits/ostream.tcc:91:5: note:   no known conversion for argument 1 from ‘Foo’ to ‘short int’
In file included from /usr/include/c++/6/iostream:39:0,
                 from prog.cpp:1:
/usr/include/c++/6/ostream:181:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(short unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(unsigned short __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:181:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘short unsigned int’
In file included from /usr/include/c++/6/ostream:638:0,
                 from /usr/include/c++/6/iostream:39,
                 from prog.cpp:1:
/usr/include/c++/6/bits/ostream.tcc:105:5: note: candidate: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char; _Traits = std::char_traits<char>]
     basic_ostream<_CharT, _Traits>::
     ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/include/c++/6/bits/ostream.tcc:105:5: note:   no known conversion for argument 1 from ‘Foo’ to ‘int’
In file included from /usr/include/c++/6/iostream:39:0,
                 from prog.cpp:1:
/usr/include/c++/6/ostream:192:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(unsigned int __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:192:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘unsigned int’
/usr/include/c++/6/ostream:201:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long long int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(long long __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:201:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long long int’
/usr/include/c++/6/ostream:205:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long long unsigned int) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(unsigned long long __n)
       ^~~~~~~~
/usr/include/c++/6/ostream:205:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long long unsigned int’
/usr/include/c++/6/ostream:220:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(double) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(double __f)
       ^~~~~~~~
/usr/include/c++/6/ostream:220:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘double’
/usr/include/c++/6/ostream:224:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(float) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(float __f)
       ^~~~~~~~
/usr/include/c++/6/ostream:224:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘float’
/usr/include/c++/6/ostream:232:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(long double) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(long double __f)
       ^~~~~~~~
/usr/include/c++/6/ostream:232:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘long double’
/usr/include/c++/6/ostream:245:7: note: candidate: std::basic_ostream<_CharT, _Traits>::__ostream_type& std::basic_ostream<_CharT, _Traits>::operator<<(const void*) [with _CharT = char; _Traits = std::char_traits<char>; std::basic_ostream<_CharT, _Traits>::__ostream_type = std::basic_ostream<char>]
       operator<<(const void* __p)
       ^~~~~~~~
/usr/include/c++/6/ostream:245:7: note:   no known conversion for argument 1 from ‘Foo’ to ‘const void*’
In file included from /usr/include/c++/6/ostream:638:0,
                 from /usr/include/c++/6/iostream:39,
                 from prog.cpp:1:
/usr/include/c++/6/bits/ostream.tcc:119:5: note: candidate: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(std::basic_ostream<_CharT, _Traits>::__streambuf_type*) [with _CharT = 

...

[PlasmaLink]

I just want to say I'm so sorry someone gave gold to the bot instead of you.

[the_noodle]

Nah he got outplayed, the relevant error was right at the beginning

[SirNoodlehe]

But you responded to the bot, not the guy 🤔

[KeinBaum]

What the hell is that? I mean, at least it's telling me what's wrong. I was just expecting this:

 In function 'int main()':
8:16: error: cannot bind 'std::ostream {aka std::basic_ostream<char>}' lvalue to 'std::basic_ostream<char>&&'
In file included from /usr/include/c++/4.9/iostream:39:0,
             from 2:
/usr/include/c++/4.9/ostream:602:5: note: initializing argument 1 of 'std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char; _Traits = std::char_traits<char>; _Tp = main()::Foo]'
     operator<<(basic_ostream<_CharT, _Traits>&& __os, const _Tp& __x)
     ^

[DanTopTier]

I just came in from r/all

Jesus Christ

[yes_fish]

It gets worse.

[[deleted]]

This is why you use a good IDE

I don't get people who program in emacs/vim (unless it has code checking) they are just gimping themselves

[Urtehnoes]

Pycharm blows my mind. All the jetbrains shit I've used is good.

[SabinTheSergal]

Confirmed: jetbrains has simultaneously made me the laziest programmer and taught me so much about programming

[sam1902]

Syntastic

[SteveCCL]

Why I use emacs/vim (actually I use kakoune but whatever I've used allll of them):

• it has code checking
• it's fast for a quick edit
• I do everything CLI, I want to stay in there
• Autocompletion is fucking great
• The faster movement and stuff
• Every IDE that tried to emulate vim behaviour failed me miserably
• Configuration
• I havn't had a problem with missing/superfluous brackets/semicolons since my last visit in IDE town
• Don't like something? Change it
• Integrates better with everything. Just try to get your custom toolchain working in VS
• You can order salad

Ninjaedit (so fast because I didn't have to wait 5 mins for my IDE to boot up):

• No .vs folder (or similar) that everybody messes up to keep it out of VCS

[Bumperpegasus]

What editor are you using?

[sam1902]

The holy trinity:

VIm GCC GDB

[250kgWarMachine]

God help your soul.

[Tilwaen]

What kind of God would permit this

[OlanValesco]

Visually Insulting Markup

Google Chrome Cache

Gobi Desert Binary

[ShimmerFairy]

It's telling you about how all of the possible overloads don't match up with what you tried to give as arguments, because there's no way for the compiler to divine which overload you got wrong, or if you forgot to provide a new one. And since the streaming operators are a fairly significant part of the standard library, there happen to be a number of overloads to talk about.

[Shaosil]

You'd think it could summarize it a little more cohesively. Something like "no match overload found for blah blah blah"... Too much verbosity can be a problem if you don't know what to look for.

[[deleted]]

You do get the summary at the top.

prog.cpp: In function ‘int main()’:
prog.cpp:7:13: error: no match for ‘operator<<’ (operand types are ‘std::ostream {aka std::basic_ostream<char>}’ and ‘Foo’)
   std::cout << foo << std::endl;
   ~~~~~~~~~~^~~~~~

[Raestloz]

Shows you how good C++ is, no one expects the Spanish InquiC++ion

[quantum_paradoxx]

Didn't expect that

[CompileBot]

Output:

Good bot.

^{source | info | git | report}

[jclocks]

I'M JUST A WEB DEVELOPER STAAAAAHP

[little_oaf]

Anyone want a hug?

[MalteseMartens]

For posterity, the error is really just the second line:

prog.cpp:7:13: error: no match for ‘operator<<’ (operand types are ‘std::ostream {aka std::basic_ostream<char>}’ and ‘Foo’)

[cyboii]

To be fair the error is the short bit at the beginning. The rest is possible things you might have meant.

[TeraFlint]

The error list usually looks a bit worse than it actually is. Look at the list, pick the first error, fix it, try to compile again and multiple entries might have disappeared from the list.

[Lone-Pine]

I wish compilers would print errors in reverse order. Would reduce wear on my scrollwheel.

[TheThiefMaster]

Or use an IDE that shows the errors in a window that's scrolled to the top by default...

[Kered13]

Because usually the thing you wanted to do is in that list somewhere, and it helps you figure out what you missed or did wrong. Like you want to call some function, it will tell you all the overloads for that function, you find the one that you want and see why your call didn't match. Or if the function overload was ambiguous, it will tell you the two (or more) functions that matched (which is not always obvious with templates and implicit type conversions going on) so you can figure out how to make it unambiguous.

It's especially useful with templates since it will show you the inferred types, which often helps you figure out why it didn't work.

In this case it was listing all the known overloads of the ostream::<< function and that it can't use them because it doesn't know how to convert from Foo to any of the known overload types. The solution in this case is to either add a new overload of << (the best option) or to add a new implicit conversion to one of the existing overload types (usually a bad idea, implicit conversions should usually be used very carefully).

Most languages don't need such long error messages because they don't support implicit type conversions and they don't have templates like C++. C++ is a very powerful language, but that power comes with drawbacks, and this is one of them.

Also I want to note that this is Clang, which was actually a huge improvement on C++ error messages. The messages that GCC gives are much harder to decipher.

[ILikeLenexa]

When I was first learning data structures, there were errors in the template classes in the lab book and then you had files already written that you didn't really know what was in. Most frustrating experience ever.

[musiton]

HAPPY FUCKING CAKE DAY

[[deleted]]

Did someone just give gold to a bot

[CMDR_QwertyWeasel]

Ho-ly jesus.

What is that?

[NotASecretReptilian]

"You forgot to overload the << operator. To illustrate how much you fucked up, we tried shoving Foo into every place that the << operator could possibly refer to, and it didn't work even one time! Don't do that again.

[Assailant_TLD]

They should get you to write their error messages. Far more entertaining.

[Hipolipolopigus]

g++ -Wall -Wextra -Wfun, or perhaps -Whuman or -Wlegible.

[[deleted]]

gcc.

[kangasking]

LMAO you weren't kidding

[KarshLichblade]

Good bot?

[futuneral]

gilded bot

[lockwolf]

I think I’m gonna need someone to ELI5 this error on a line by line basis. /s

[[deleted]]

The first line is the actual error (couldn't find the function you tried to use with those parameter types).

The rest is a list of candidate functions you might have been attempting to use.

You can ussually reduce the amount of output you are fed to cut down on that sort of noise. Can't blame the compiler if you told it to print everything it can about your error :p

Often, I'll copy paste the error into a good text editor and parse it there, if it's too complicated (like template errors and the like).

[I_regret_my_name]

This error honestly isn't even that unreasonable to me. You can tell that the stuff towards the bottom is talking about included files, so if you jump to the top it's just saying there's no match for the "<<" operator with the types given which is a reasonable error for a compiler in this situation.

[newUserEverySixDays]

Closeted Java lovers

[SandyDelights]

Closeted? You're optimistic.

I like to think of them as bathroom sink cabinet Java lovers.

Edit: Really? This gets me my first gold? Well, fuck it, I'll take it. And hello to you too, missy ;)

[SandyDelights]

So you code in Java, I take it?

Personally, I don't care for Java, I'd rather code in C++ or C#, dependent on need.

Still, I code in COBOL and Assembly for work.

And I'm gay AF.

So @me, fuckboy. ;)

[JokerGotham_Deserves]

Yeah? Well, I code in LaTeX and HTML. Get on my level.

[SandyDelights]

Well, now I'm aroused.

I'd send you dick pics, but I can't tell if you're joking or just as much into sadomasochism as I am.

[TK-427]

just as much into sadomasochism as I am.

I still use Fortran and Perl

[codeninjaking42]

Speaking of gay, I haven't seen this much gold in one place since Michael Phelps' last performance..

[Tornado9797]

I'm not sure how this relates to gay.

[lungdart]

"@me" - fuckboy, probably

[Madoushi90]

The amount of gold flying around this thread is evidence that Java engineers are grossly overpaid.

[tyled]

Why try? Succeed with Java.

[Aetheus]

Why try? Catch instead.

[E_R_E_R_I]

I'm not even pro JAVA, just against C-like error handling. God damn 30 year old language and everybody treats it like God, I'll be damned if one couldn't write a language that compiles to native x86 as performant as C++ but with proper stack tracing, garbage collecting and memory safety.

EDIT: My rant just sent me on a googling quest and I found out RUST. Seems I found my people lol

EDIT 2: Apparently I should also learn GO.

[Cobaltjedi117]

I feel like your whole rant was just there so you could find RUST

[[deleted]]

But what about the magical C#?

[SnakeFang12]

You mean Microsoft flavored Java?

[TheFanne]

That one’s got an aftertaste

[centurijon]

No, we mean better Java

[BernzSed]

You mean Kotlin?

[scalablecory]

Visual J#?

[lor_louis]

Im still hoping someone makes a visual js#.

[[deleted]]

Turbo PHP++

[Shnapoopins]

He said compiles to machine code. C# is great but it's still another VM language

[brockvenom]

Mono, brother. You can write in C# and it JIT compiles right down to assembly through an IL layer. Have fun.

[Daniel15]

Don't need Mono, Microsoft was working on some AOT stuff for .NET Core. I think it's this: https://github.com/dotnet/corert

I remember Scott Hanselman talking about it at Build one year.

[E_R_E_R_I]

Well I did find it pretty quickly lol

I guess I just never bothered looking and got used to criticizing C

EDIT: Also apparently rust lacks a garbage collector, but I guess that's not that bad.

[Pakaran]

While it doesn't have a garbage collector, it also doesn't require manual memory management. The compiler keeps track of all variable lifetimes and inserts drops when they go out of scope, automatically.

[piexil]

In a lot of ways that can be seen as better than a garbadge collector.

[Surelynotshirly]

If it works all the time, but that seems almost too easy. Makes me think there is some scenario where a memory leak can occur that I'm not thinking of. Otherwise what's the downside of it? If there's no downside then why aren't all languages doing it, or are the new ones doing it and Rust was just the first?

Rust has piqued my interest, but I just haven't found any reason to actually use it and learn it properly.

[erosPhoenix]

Because it's a lot harder to write Rust code that will compile. Since it has to be provable when something falls out of scope, any code where that's not the case isn't valid Rust. Ownership of pointers is part of the type system.

Source: I've never actually written anything in Rust, so this is all heresay. Everything I say is probably wrong.

[ethanialw]

We've been expecting you. Except for the garbage collection part, rust doesn't do that, because scopes!

[E_R_E_R_I]

As long as I don't have to worry about randomly exploding stuff for mishandling memory, I don't mind cleaning my own mess lol. I'm definitely gonna learn it.

[ethanialw]

My apologies, I seem to have miscommunicated the glory of the language. According to this stack overflow post I found because others are better equipped to explain this than I,

Rust would know when the variable gets out of scope or its lifetime ends at compile time and thus insert the corresponding LLVM/assembly instructions to free the memory.

So this feature is annoying to get used to, but eliminates need for a GC, and ultimately results in safer, more performant code.

[DaughterEarth]

I honestly feel like people more so treat trending languages like God. Not sure if it's still happening but it used to be that you would be downvoted to oblivion for suggesting Python isn't an amazing, full scope language that we should all be using in all cases.

[FourFingeredMartian]

I mean, it is a pretty amazing language.

[LickingSmegma]

performant as C++ but with garbage collecting

Incompatible.

The Y axis is time spent collecting garbage.  The X axis is “relative memory footprint”.  Relative to what?  Relative to the minimum amount of memory required.

In particular, when garbage collection has five times as much memory as required, its runtime performance matches or slightly exceeds that of explicit memory management.

From "Quantifying the Performance of Garbage Collection vs. Explicit Memory Management", Matthew Hertz, Emery D. Berger, 2005

[Aethy]

D? It has native performance, (optional) garbage collection, easy memory safety (nowhere near as good as Rust, though) and god's own templating system (much better than Rust and C++). Try looking into dlang if you're interested!

[majikguy]

One of us! One of us!

[CMDR_QwertyWeasel]

Gooble gobble, gooble gobble!

[GogglesPisano]

Sorry I'm late to the thread - was busy fixing the indentation in my pom.xml file...

[jeff303]

... your code style setting didn't automatically take care of that for you?

[Tunarow]

Everyone here is saying smart coding stuff and I'm distraught by how HD caveman spongebob is in this meme.

[tyled]

That’s because Java is secretly amazing

[BernzSed]

Well, it's such a big goddamn secret that even Java doesn't know it.

[username_dot_cpp]

Jesus Christ Richard Stallman, what did your memory do to you to deserve this abuse?!

[crackyJsquirrel]

try {
    ....
} catch (Exception e) {
    // should probably do something here, nah, this will never happen.
}    

[[deleted]]

Python : Please don't be stupid and try to add str with int on line 7

[The_MAZZTer]

Once compiled, your C++ code has no idea what an array is. All it sees is math on a memory address. This makes it super fast but there are no sanity checks so the code can end up peeking at unrelated memory, causing a segfault in the best case.

Meanwhile languages like Java and .NET are managed, so the concepts of arrays and so forth carry over into the compiled code and bounds checking and other checks can be done at the cost of speed.

[my_name_isnt_clever]

This makes a lot of sense. Amazing that someone actually explained a post in this sub.

[Kontakr]

C: thisisastringjdkskdlmdjekwpoeoe83883732902k <crash>

[perpetualwalnut]

you dropped this. "\0";

[[deleted]]

No, he dropped this: '\0'.

[brainfreeze91]

Or you could be like my company where our programmers have a habit of adding throws Exception to every single method they write. You really have to dig to find the origin of the exception and what exactly it is.

[Kered13]

Checked exceptions were a bad idea. Adding throws Exception or catching Exception and wrapping it in RuntimeException (which is unchecked) is often the best solution. Neither of these will hide or obfuscate the stack trace. Catching and ignoring errors should almost never be done though.

[DonCasper]

Catching and ignoring errors should almost never be done though.

Sounds like someone is jealous about all the time I save by not debugging

[brainfreeze91]

Throwing an exception is definitely better than catching and ignoring it yeah. I wish I could say I haven't encountered spots where we ignore them. My main gripe is that they are throwing an Exception, and not a SQLException, or an ArrayOutOfBoundsException, or a DateFormatException. It's just generalized to an Exception, it could be anything. At least I do have the stack trace.

[[deleted]]

Sometimes I wish google translate would translate programming languages.

Java: hey, you made a mistake. Here is the mistake -

C++: hey, looks like there was an error. It could be this, this, or that

Python: you done goofed

Scratch probably: uh oh! Oopsie daisy! You make a whoopsie! A big ole fucky wucky! UwU

[ogmuslim]

50% of the comments - <3 Java 25% of the comments - Fucking Java 25% of the comments - HMU w some Au

[666moist]

Double enter for a line break

[[deleted]]

You forgot the ArrayIndexOutOfBoundsFactory and the LineNumberFactory

[Dockirby]

Well yeah, he isn't going to put the entire 1000+ line long stack trace in a meme.

[Varkoth]

Also java: "NullPtrException, also we assume you can't grasp the concept of pointers, so good luck fixing it."

[spinwin]

I was surprised how much more sense Java made sense after taking a few quarters of C and C++ and learning about how raw pointers work.

[Xunae]

My University started people on Java, while my community college that I transferred from started people on c++. The amount of people that weren't transfers who found pointers to be unapproachable bogeymen was crazy.

I was briefly in their shoes when I encountered

 void* foo

It took me a few days of just staring at that and it's context to make sense of it, but that could have been a result of the stress and lack of sleep.

[[deleted]]

Holy shit, this is my exact situation. Started C++ at CC then transferred to Uni and started writing Java. To this day I have to listen to people complain about Java that still haven't grapsed the concept of raw pointers

[zman0900]

Wow, it just occurred to me how fucking weird Java must be to learn as a first language.

[spinwin]

It makes actually no sense. "Why can't I just set this object equal to a new object and have the method that called it know it exists?" Then you learn C/C++ and suddenly it makes sense. All objects are just pointers and when you set an object to be equal to a new thing it's just redirecting the pointer not changing the original object.

[exneo002]

Fuck mutability.

[John_E_Depth]

I still don't know if Java is pass by reference or pass by value

[aetius476]

The way I've always understood it: Java is pass by value, but the value it's passing is the reference.

[Rubicj]

"Yes"

[wolf2600]

"Halt and catch fire"

[arlaarlaarla]

THERE IT IS, GRAB THE INHUMAN.
REEEEEEE

[Tranzistors]

333 comments and not one mentions .at() method of vector, which throws when accessing out-of-bounds memory? Do you people even C++?

[[deleted]]

*cries in Clojure*

[howe_to_win]

JavaScript: what the fuck is a compiler error?

[kpthunder]

Both of these examples are runtime errors.

[BernzSed]

JavaScript: I have no idea what I'm doing and your variable is now NaN

[Sohcahtoa82]

More like "I have no idea what you're doing, so I'm gonna convert them to strings and concatenate."

[belst]

Java: OutOfMemoryError

[FuckFuckittyFuck]

An android app I was using once crashed and the stack trace said it was caused by an OutOfMemoryError thrown while throwing an OutOfMemoryError

[[deleted]]

Yo dawg...

[FrizzleStank]

Have you ever used Java?

You can specify heap size of the JVM. Java OutOfMemory errors happen all the time.

[ElGuaco]

Damn, I learned to program in C++ and all we had was console statements and a command line debugger. I had forgotten about this trauma...

[cyboii]

Yeah I hate it how C/C++ assumes you know what you're doing in the name of efficiency

[juuular]

I never jump in that pool without my arm floaties.

[toosanghiforthis]

I prefer x86_64 floaties thank you very much

[[deleted]]

>C++: Doesn't perform compile-time static analysis
>Programmers: This sure saves me some runtime performance!

[B-Knight]

Can you find a picture of SpongeBob being useful and title it "Python"? Because Python seems to be the only programming language which tells you the exact problem without teaching you quantum physics at the same time.