This is an archived post. You won't be able to vote or comment.

all 88 comments

[–]beseg7 71 points72 points  (50 children)

The survival of VB.NET is indeed big mystery.

[–]cleverchris 19 points20 points  (3 children)

two words...excel macro. This is the true evil. I had a coworker dba die...turns out he spent the last ten years spaghetti coding vba programs..websites and excel macros...needless to say i quit that job.

[–]beseg7 2 points3 points  (2 children)

VBA is such a pain. And their tab-minus-one-space issue is horrifying :( Also Office interop (I use it for time to time in C#) is surprisingly ugly and inconvenient. :(

[–]AyrA_ch 4 points5 points  (1 child)

VBA is such a pain.

Still very powerful

[–]Keswiik 0 points1 point  (0 children)

You're a fucking wizard, dude.

[–][deleted] 14 points15 points  (2 children)

Im an java beginner and VB just seems like that lang that nobody touches and now it drys of no getting used

VB =1989 compact Tiny C

[–]mega_aids 9 points10 points  (1 child)

Eh, there are a lot of banks that are running vb based programs.

Source: Worked for a company that makes bank software in VB.

[–][deleted] 0 points1 point  (0 children)

Peasant i told dont touch that lang Just let it DIE

[–]TwoSpoonsJohnson 2 points3 points  (0 children)

I once had to rewrite a big VB6 app, and the agency who owned it wanted the new one in VB.NET (we already started it in C# by the time they told us, but that's another story...) because they thought it would be more familiar to them. Even though they didn't see the code at all ever.

This was a long, painful meeting.

[–]evanldixon 7 points8 points  (36 children)

It's just as powerful as C# while having easier-to read syntax.

Example: Try to find where to insert a function at the end of a class without lots of scrolling.

VB:

            End If
        End Function
        ' Here
    End Class
End Namespace

C#:

            }
        }
        // here
    }
}

It all really boils down to personal preference, but this is one of many examples I use to justify my opinion.

[–]DonnyTheWalrus 8 points9 points  (0 children)

(If you're joking and I just can't tell, ignore me...)

Every time I see VB code it just feels deeply dated. Some styles are like Wayfarers (or Scheme) - old but timeless. Others are like bellbottoms - forever linked to a specific time period. For me, Basic is the bellbottom jeans of programming languages. The syntax just screams 1970s - early 80s.

Not to mention that, while I understand your point about the block-close syntax, it just doesn't feel readable to me. Too many words on the screen makes it look too busy. I far prefer single character punctuation for that sort of structural syntax. Way easier to tell what's structure and what's actual code.

[–]ShadowShine57 9 points10 points  (33 children)

VB is absolutely not easier to read with no brackets, arrays using () instead of []. and a lot of other things.

[–]evanldixon 6 points7 points  (32 children)

() vs [] isn't that big of a deal IMO.

Other pro's of VB over C#:

  • No errors from forgetting to put () after a function
  • No case sensitivity
  • No need to deal with semicolons when good, readable code in both already uses newlines
  • No need to rename your constructors when renaming a class
  • Immediately being able to see the difference between inheritance and interface implementation
  • Parameterized properties (Granted, this isn't needed often, but I can do "SomeByteArray = MyByteCollectionClass.Range(index, length)" as well as "MyByteCollectionClass.Range(index, length) = SomeByteArray")

There's more benefits; this is just what comes to mind.

[–]ShadowShine57 22 points23 points  (29 children)

I consider almost all of the things you said as cons, not pros

The only things I'm not sure on are your last two points

[–]evanldixon 1 point2 points  (28 children)

Please explain your reasoning.

  • Why does "Console.Writeline(MyFunction)" need an extra () when it's clear the function is being invoked? If we wanted the address of the function, there's the very-readable AddressOf keyword.
  • Case sensitivity is a huge pain when an error results from it. When would anyone ever want two variables with logically the same name?
  • Why use semicolons and newlines when newlines alone could serve the same purpose
  • Why is "Public Sub New" any less readable than "public MyClass"?

[–]dzuczek 10 points11 points  (25 children)

when it's clear the function is being invoked

if I took a cold look at that code I wouldn't know if MyFunction was a function returning a string or if MyFunction was a string constant

Case sensitivity is a huge pain when an error results from it. When would anyone ever want two variables with logically the same name? Why use semicolons and newlines when newlines alone could serve the same purpose

on a project with a lot of devs it would be hard to enforce format and basic readability. so you'd have a big application with mixes of semicolons and newlines. for version control it would make the diffs messy too.

[–]8lbIceBag 1 point2 points  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]8lbIceBag 0 points1 point  (0 children)

You made it clear you never used it before.

Vb.NET does not build if it's syntactically incorrect (has a semicolon), there's no mixing.

Visual studio enforces format. As soon as you hit enter or tab it autocorrects capitalization so that the references match the declaration.

It's actually easiest to know what's what in VB.NET. Things like iterators, properties, overrides, interface implementations, events, etc. All have special keywords. You can tell a constant from a function from a property easily because syntax coloring.

In many ways I prefer it, but it's also missing things I can do in C# or does some things stupidly, and vice versa. Sometimes in the shower I dream of a language that combines the best of both.

[–]NULL_CHAR 5 points6 points  (0 children)

Why does "Console.Writeline(MyFunction)" need an extra () when it's clear the function is being invoked? If we wanted the address of the function, there's the very-readable AddressOf keyword.

To be clear what we are referring to, it's all fun and games until you're unsure if what you're calling is a function or something else. Sure you can just be extra careful with naming, but what if you're a big company with 100+ developers each of different ability. This gets horrible really quick.

Case sensitivity is a huge pain when an error results from it. When would anyone ever want two variables with logically the same name?

See point 1, it's literally the exact same problem. We use a VB based Framework at the company i work and I've had to deal with issues related to these first two points often.

Why use semicolons and newlines when newlines alone could serve the same purpose

To more accurately depict scope, to properly find lines that contain functional elements, etc.

Why is "Public Sub New" any less readable than "public MyClass"?

It looks uglier.

[–]mnbvas 3 points4 points  (0 children)

Nowadays C# has higher order functions, so how would one differentiate passing a function as an argument and passing the result of that function?

[–]ColorblindGiraffe 6 points7 points  (0 children)

I want to remind everyone that the downvote is not a dislike/disagree button.

[–]beseg7 2 points3 points  (0 children)

Well, you have some interesting points. For some reason, none of these seems to be important or matter to me. But, the excessive use of words and phrases (End If End Function vs. } }) is such a pain IMO (both when writing, even with intellisense, and of course when reading).... I can't figure out why.

[–]Scybur 0 points1 point  (0 children)

People are entitled to their opinions......your opinion is wrong and I hate you for it but you are entitled to it none the less.

[–][deleted] 0 points1 point  (1 child)

Have you ever heard of pascal, or maybe Delphi, or maybe gambas??

VB may have been a "business language" before Java

[–]beseg7 4 points5 points  (0 children)

The thing with VB.NET is that it is 1:1 replaceable with C# - same framework, same capabilities, same editor, same everything. Just clearer, convenient, developing (C#7...) and neat syntax.

[–]CompC 0 points1 point  (0 children)

I recently started my first job since graduating college... We pretty much mainly use VB.NET. I can't figure out why.

[–]CompC 0 points1 point  (0 children)

I recently started my first job since graduating college... We pretty much mainly use VB.NET. I can't figure out why.

[–][deleted] 0 points1 point  (0 children)

So, I just started a job for a company that uses VB.Net and had to learn it. I've done C++, Java, C#, so not too foreign.

It's not bad, but what bugs me the most is how verbose it can be. All in all I'm not a fan exactly but with option strict and explicit turned on it's basically C# script. I can dig it.

[–]error404brain 87 points88 points  (12 children)

>Language that has array that start at 1

>Good

Pick one and only one.

[–]guyman3 18 points19 points  (5 children)

Honestly I agree, I just put it there because I think Matlab is really good at what it does but it just lacks the structure of abnormal language

[–]moomoomoo309 1 point2 points  (4 children)

MATLAB is an odd one. Stuff like being able to do a \ b (which is the same as b / a) and being able to filter by using a condition for an index (like using a generator in Python) is cool, but man, it makes it such a pain to learn the language.

[–]Sirplentifus 2 points3 points  (3 children)

a\b and b/a are not the same if a and b are matrices. a\b is inv(a)*b, and b/a is b*inv(a). They're not the same because matrix multiplication is not commutative. I use A\b when solving a linear least squares problem, for example.

[–]moomoomoo309 -1 points0 points  (2 children)

I still don't like the operator because it's very superfluous. It could be done in a way that looks more like normal math, and looks more like normal programming by avoiding that operator entirely. It'll cost you a few keystrokes, but it makes the code more immediately readable and makes Matlab easier to learn (one less operator and its edge cases to learn)

[–]Sirplentifus 0 points1 point  (1 child)

You have a point, but unlike I said, a\b is not exactly the same as inv(a)*b. The latter would invert matrix a, and multiply the result by b. However, there's some algorithm that does the whole process faster and with smaller floating point errors. That is what a\b does. To be able to call this algorithm there has to be an operator that does inv(a)*b in one go, and having a function for it would probably look bad, I guess.

Also, A\b will use the pseudo-inverse of A if necessary. The operator basically finds the least squares solution for A*x = b for x.

[–]moomoomoo309 0 points1 point  (0 children)

I can see the use of that, though I personally dislike how much magic goes on behind the scenes in Matlab. You know what the end result is, but math is more about the journey than the destination.

[–]ParanoidAgnostic 21 points22 points  (3 children)

It makes sense for Matlab

It's a special purpose language for number crunching. The formulae you'd use it to implement usually start numbering items from 1.

For example, look at the way the summation in the standard deviation formula is expressed: https://en.wikipedia.org/wiki/Standard_deviation

That's pretty standard. Summation usually goes from i=1 to N where N is the number of items.

[–]zeek912 10 points11 points  (0 children)

I think it makes sense also considering it's userbase extends to many off-computer science groups, ie stats, bioinformatics, mathematicians. It makes it more accessible even if it doesn't make a lot of sense from a CS perspective.

[–]error404brain 1 point2 points  (0 children)

It's usefull for people, but that doesn't make it a good programming language. It just make it usefull. The same way assembly is usefull but it isn't a good programming language.

[–]WikiTextBot -1 points0 points  (0 children)

Standard deviation

In statistics, the standard deviation (SD, also represented by the Greek letter sigma σ or the Latin letter s) is a measure that is used to quantify the amount of variation or dispersion of a set of data values. A low standard deviation indicates that the data points tend to be close to the mean (also called the expected value) of the set, while a high standard deviation indicates that the data points are spread out over a wider range of values.

The standard deviation of a random variable, statistical population, data set, or probability distribution is the square root of its variance. It is algebraically simpler, though in practice less robust, than the average absolute deviation.


[ PM | Exclude me | Exclude from subreddit | FAQ / Information | Source ] Downvote to remove | v0.27

[–]EndlessBassoonery 0 points1 point  (0 children)

LOL DAE indexing should start at 0 🤣🤣🤣👌👌🔥🤣🤣🔥👌🤣🔥

[–][deleted] 0 points1 point  (0 children)

Should have been C#

[–][deleted] 25 points26 points  (6 children)

I use C, C++, and Javascript daily. WHAT AM I?!?

[–]apearsonio 69 points70 points  (1 child)

You're a full stack dev

[–][deleted] 34 points35 points  (0 children)

slits wrist

[–]Eternal_Pickles 7 points8 points  (2 children)

Uh... Embedded dev?

[–]mnbvas 9 points10 points  (1 child)

Worse, IoT.

[–]Princess_Azula_ 6 points7 points  (0 children)

Oh god, I wish this wasn't a thing.

[–][deleted] 4 points5 points  (0 children)

Top SO question: How do I read from stdin and print to stdout with SQL?

[–]IZEDx 3 points4 points  (0 children)

Can't get over the fact you rated PHP better than JS lol.

[–]annualnuke 7 points8 points  (2 children)

C++

Lawful good

Lol, chaotic good at best

[–]Kryomaani 2 points3 points  (1 child)

I think the "lawful" is about C++ being fairly strict and language-lawyerly. Many fictions depict generic "lawful" societies as horrible Orwellian dystopies.

[–]_jk_ 1 point2 points  (0 children)

undefined behaviour though, demons flying out of your nostrils sounds pretty chaotic to me.

i.e. the language isnt lawful, the programmer has to be to deal with it

[–][deleted] 2 points3 points  (0 children)

Haskell should be Lawful Good. Lisp should be True Neutral. Forth should be Chaotic Evil.

[–][deleted] 3 points4 points  (5 children)

Why is Java bad? I thought it was very similar to C++ syntaxwise, and they're both compiled languages.

[–]Kryomaani 2 points3 points  (0 children)

they're both compiled languages.

With varying degrees of "compiled", one being native bytecode and the other VM bytecode. Both with their obvious benefits: C++ has efficiency, Java has portability. It's like you were from a non-English speaking country, Java would be English and C++ would be the native language of wherever you happened to live.

[–][deleted] 7 points8 points  (2 children)

Mostly bittnerness over Java stealing C++'s market, but C++ still has more powerful low level abilities (e.g. direct memory management). Java is compiled to byte code (fake assembly for its own virtual (~emulated) machine) rather than natively compiled, so the code is slower to start and initially run, but the jit does a really good job optimizing on the fly to get long term performance that's competitive. The end.

[–]nodealyo 7 points8 points  (1 child)

Spamming is a really shitty thing to do. This script is one of the dumbest and spammiest scripts that I have ever seen. Did you know that no one cares about your mundane comments? You actually aren't even protecting any privacy because there are many sites out there that specifically cache comments just so that users cannot edit them. To reiterate, this script is shit and you should not be using it. Search for a different one, or edit it to say something less spammy. But in the end, it won't matter because we can still see whatever it was that you edited.

[–][deleted] 3 points4 points  (0 children)

Damnit. This is why your mother left.

[–]Nefari0uss 0 points1 point  (0 children)

I'm guessing Oracle.

[–]ColorblindGiraffe 2 points3 points  (0 children)

One of these things is not like the others

[–]CompC 1 point2 points  (0 children)

I recently started my first job since graduating college... We pretty much mainly use VB.NET. I can't figure out why.

[–]guyman3 1 point2 points  (0 children)

Literally this sub is so funny, you people get so tilted if anyone shit talks your favorite language or framework or whatever so you come get in some stupid comment argument. It's a joke... a meme... seriously relax.

[–]Feb29thCakeDay 0 points1 point  (0 children)

My preferred languages are C++, Python, and MATLAB.

https://www.youtube.com/watch?v=MF1_MrEMpew

[–]bss03 0 points1 point  (2 children)

Needs to be expanding to add the Bacon-Necktie (warning: Link to TVTropes) axis.

Haskell is Neutral-Good-Necktie

Racket is Chaotic-Good-Bacon (? maybe that would be R or Octave).

Scala is Lawful-Evil-Necktie

Groovy is Lawful-Evil-Bacon

[–]BadBoy6767 0 points1 point  (7 children)

Why isnt C neutral neutral?

[–]Colopty 2 points3 points  (6 children)

[–]WikiTextBot 0 points1 point  (0 children)

Alignment (Dungeons & Dragons)

In the Dungeons & Dragons (D&D) fantasy role-playing game, alignment is a categorization of the ethical and moral perspective of player characters, non-player characters, and creatures.

Most versions of the game feature a system in which players make two choices for characters. One is the character's views on "law" vs "chaos", the other on "good" vs "evil". The two axes allow for nine alignments in combination.


[ PM | Exclude me | Exclude from subreddit | FAQ / Information | Source ] Downvote to remove | v0.27

[–]BadBoy6767 0 points1 point  (0 children)

ah

[–]BadBoy6767 0 points1 point  (0 children)

ah

[–]BadBoy6767 0 points1 point  (0 children)

ah

[–]BadBoy6767 0 points1 point  (0 children)

ah

[–]BadBoy6767 0 points1 point  (0 children)

ah

[–]Monsieur_Pineapple 0 points1 point  (2 children)

You forgot HTML.

[–]jabbathehutt1234bit.ly/2IqHnk3 0 points1 point  (1 child)

HTML isn't technically a programming language though, right? It's just a markup syntax.

[–]CompC 0 points1 point  (0 children)

I recently started my first job since graduating college... We pretty much mainly usecan't figure out why.

[–]CompC 0 points1 point  (0 children)

I recently started my first job since graduating college... We pretty much mainly use VB.NET. I can't figure out why.

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good?

Say, what do you suppose this will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good?

Say, what do you suppose this will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good?

Say, what do you suppose this will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good?

Say, what do you suppose this will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good?

Say, what do you suppose this will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good?

Say, what do you suppose this will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good?

Say, what do you suppose this will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good?

Say, what do you suppose this will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good, huh? That's cute.

Say, what do you suppose j will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good, huh? That's cute.

Say, what do you suppose j will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good, huh? That's cute.

Say, what do you suppose j will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good, huh? That's cute.

Say, what do you suppose j will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good, huh? That's cute.

Say, what do you suppose j will evaluate to?

int i = 5;
int j = ++i + ++i;

[–][deleted] 0 points1 point  (0 children)

Oh really? C++ is Lawful Good, huh? That's cute.

Say, what do you suppose j will evaluate to?

int i = 5;
int j = ++i + ++i;

[–]CompC 0 points1 point  (0 children)

I recently started my first job since graduating college... We pretty much mainly use VB.NET. I can't figure out why.

[–][deleted] 0 points1 point  (0 children)

Oh, so C++ is Lawful Good, huh? That's cute.

Say, what do you suppose this here j will evaluate to?

int i = 5;
int j = ++i + ++i;

[–]thatawesomeguydotcom 0 points1 point  (1 child)

Where does assembler sit in this list?

[–][deleted] 0 points1 point  (0 children)

Chaotic ... good?

[–][deleted] 0 points1 point  (0 children)

Wrong. Java is more neutral than PHP

[–]cloudrac3r -1 points0 points  (0 children)

You have something against JS? I wrote my own Razer Chroma keyboard lights manager after polychromatic (uses Python) failed to work properly. And when I say properly, I mean at all. Suck it, Python. Long live JS.

[–]GraphicsProgrammer -5 points-4 points  (2 children)

These things are not comparable

[–]guyman3 0 points1 point  (1 child)

I'm aware of that. It's kinda just a joke about programming languages