Print

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

[Muz]

C++ is still used because it works well. Like English. I like it.. even with tons of code, it's fine. C++ is used mostly because it's what everyone learns at uni, isn't necessarily the best, but it's the most well known.

I heard Python is better for games.

You should choose between those two. If you plan to work with others, C++ is a better choice.

[smigenboger]

Might have been said before, but if you are making a program whose code will never be looked at or changed, C++ would be great, and if the code is going to be fickle, or if others will have to mudle through it, Python would be great


(For instant examples of how code works, 'View Source' your favorite web pages)

((Why is favorite not considered a word on here, but electrocardiogram is?))

[Andir]

Did your spell checker get stuck on British English?  ( I think they spell it favourite. )  In Firefox it can be easily changed in the right click menu.

[Blacken]

Though, NEVER go near C#. Microsoft wants Linux devs to use it so they can sue the crap out of them.

This is factually fucking untrue. C# is an open standard with estoppel protecting it and the BCL and CLR (requirements to gain ECMA standardization--see ECMA-334 and ECMA-335), and not a single library used in distributed GNOME applications uses libraries that are not expressly protected. I suggest you stick to being wrong about programming topics instead of being wrong about legal ones.

(Disclaimer: I am a contributor to the Mono Project. As such, I am considerably more aware of the legal situation around the topic than this joker.)



And C# is an absolute joy to work with--moreso than anything else noted in this topic. Stick to Python or C#; the rest offer you nothing that a novice actually needs. The idea that, say, C++ is "easier to work with other people" with is absolutely absurd--any remotely decent collaboration tools will support a wide variety of languages, and there's a pretty strong argument that C++ is among the worst for novice programmers due to a lack of strong tools support (Visual Studio's C++ support is pretty good, but there's nothing that compares to Eclipse's Java or Visual Studio's .NET support; semantically meaningful on-the-fly parsing of the language is difficult.)

[Jookia]

C# may be an open standard, but it's patented by the only company that declared GNU/Linux its enemy. It's a patent tra.

RMS said this about it:

The danger is that Microsoft is probably planning to force all free C# implementations underground some day using software patents. The problem is not in the C# implementations, but rather in Tomboy and other applications written in C#. If we lose the use of C#, we will lose them too. That doesn't make them unethical, but it means that writing them and using them is taking a gratuitous risk.

Microsoft extended the terms of their Community Promise to implementations of the ECMA 334 and 335 standards. You might think this means it's safe to write your software in C#. However, this promise is full of loopholes, and it's nowhere near enough to make C# safe. In May 2007, Microsoft followed all this up by announcing in a Fortune magazine interview that they believed GNU/Linux infringed 235 Microsoft patents. And recently they made it very clear that these were not idle threats: the company sued TomTom for using the VFAT filesystem implementation in the kernel Linux without buying a license from it. All of this can't simply be brushed aside. These are statements and actions made at the highest executive levels of the company. Using patents to divide and conquer the free software community is a fundamental part of their corporate strategy. Because of that, C# represents a unique threat to us. The language was developed inside Microsoft, so it's likely they have many patents to cover different aspects of its implementation. That would make free software implementations of C#, like Mono, an easy target for attack. The Community Promise does nothing to change any of this. Microsoft had an opportunity to take action and demonstrate that it meant us no harm with C#. Instead, they took meaningless half-measures that leave them with plenty of opportunities to hurt us.

The ECMA 334 and 335 specifications describe the core C# language, including information about standard libraries that must be available in any compliant implementation. However, there are several libraries that are included with Mono, and commonly used by applications like Tomboy, that are not required by the standard. And just to be clear, we're not talking about Windows-specific libraries like ASP.NET and Windows Forms. Instead, we're talking about libraries under the System namespace that provide common functionality programmers expect in modern programming languages: binary object serialization, regular expressions, XPath and XSLT, and more. Because these libraries are not defined in the ECMA specifications, they are not protected in any way by Microsoft's Community Promise. If this were the only problem with the promise, it might be safe to use applications that avoid these libraries, and stick to what's in the standard. But even the code that's covered by the promise isn't completely safe.

If Microsoft genuinely wants to reassure free software users that it does not intend to sue them for using Mono, it should grant the public an irrevocable patent license for all of its patents that Mono actually exercises. That would neatly avoid all of the existing problems with the Community Promise: it's broad enough in scope that we don't have to figure out what's covered by the specification or strictly necessary to implement it. And it would still be in force even if Microsoft sold the patents. This isn't an unreasonable request, either. GPLv3 requires distributors to provide a similar license when they convey modified versions of covered software, and plenty of companies large and small have had no problem doing that. Certainly one with Microsoft's resources should be able to manage this, too. If they're unsure how to go about it, they should get in touch with us; we'd be happy to work with them to make sure it's satisfactory. Until that happens, free software developers still should not write software that depends on Mono. C# implementations can still be attacked by Microsoft's patents: the Community Promise is designed to give the company several outs if it wants them. We don't want to see developers' hard work lost to the community if we lose the ability to use Mono, and until we eliminate software patents altogether, using another language is the best way to prevent that from happening.

[Blacken]

RMS is not a lawyer. RMS is also a fearmongering dink who has long disliked Miguel de Icaza, so he is quite biased. His dislike of C# is personal and not based on facts. Every toolchain out there is patent-encumbered, from Java to GCC to [insert whatever here].

Microsoft, while still not perfect, is getting better about being a decent corporate citizen, and C# is, for all intents and purposes, safe. I've had actual lawyers, instead of bearded assholes with fake Ph.D.'s (hint: "Dr. Stallman" refers to honorary doctorates, Stephen Colbert-style) living out of a donated office, read the Community Promise. Promissory estoppel is a positive defense, and a very strong one.

[eerr]

First of all: Ignore Jookia.
Also, blacken goes into such incredible detail, that it's a pain to listen to him.

Chat up Lightman about ASCII lab (C#-based)
You can draw ASCII to the screen without mucho trouble.
have some fun  .

[Blacken]

Also, blacken goes into such incredible detail, that it's a pain to listen to him.

[eerr]

(complains more)

[Blacken]

[smigenboger]

Now boys...

[Jookia]

RMS is not a lawyer. RMS is also a fearmongering dink who has long disliked Miguel de Icaza, so he is quite biased. His dislike of C# is personal and not based on facts. Every toolchain out there is patent-encumbered, from Java to GCC to [insert whatever here].

Microsoft, while still not perfect, is getting better about being a decent corporate citizen, and C# is, for all intents and purposes, safe. I've had actual lawyers, instead of bearded assholes with fake Ph.D.'s (hint: "Dr. Stallman" refers to honorary doctorates, Stephen Colbert-style) living out of a donated office, read the Community Promise. Promissory estoppel is a positive defense, and a very strong one.

Yes, but not every patent owners have declared themselves an enemy of GNU/Linux.
I'll see you when Microsoft pulls it's C# plan, fine sir.

[eerr]

An image of blacken

(Valid when meeting blacken at any time, in any possible situation, an accurate spot can and will be made)

http://www.silentrage.co.uk/

Spoiler (click to show/hide)

I am too lazy to copy it off the site and upload it to imageshack.
Or find a better pic.

[Blacken]

Yes, but not every patent owners have declared themselves an enemy of GNU/Linux.

Who the fuck cares? Are you really so superficial that you think something like that actually has anything to do with legally binding and non-revocable documents?

Do you know what, say, RAND means? Or estoppel? Or anything else related to patents? Do you even understand what's going on, beyond some grunting "patent bad" idea?

Maybe you should sit this one out.

[qwertyuiopas]

Maybe thay might have given sufficient legal assurance(only *maybe*, because I haven't looked it up), but have they guarenteed that any future developments to the language will fall under a similar agreement, and, if not, that they don't have an internal implementation that they will reveal for something that imitators can do but wasn't included in the initial agreement that they can use to eliminate competition?

If they wanted to make an unnoticable loophole an later use it if they feel like it, they could probably have a few thousand lawyers working on it together, and come up with something that any individual would never spot.

Alternatively, they just release a critically important feature that makes everything far easier than ever before, and decide to keep that feature themselves. Since it would be so useful of a feature, unless what they have said forces them to allow imitations, few programs could run on non-microsoft implementations.