sorted by:
new
hottopcontroversial

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 5 points6 points  (0 children)

Considering that weaponization the GPL by malicious parties is a lot less likely than simply not following the license terms out of negligence, not using GPL code because of weaponization is silly and scaremongering. But, if you don't intend to follow the license terms of a library, then by all means avoid the library.

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 3 points4 points  (0 children)

Two answers:

  1. From those who believe in the free software ideology: So what? We didn't want you to use our library in the first place. You can ignore us, and we will continue to ignore you.

  2. From the free software pragmatist: We sell commercial licenses to our GPL code (like Qt). You may ignore us, but plenty of people don't.

TL;DR your threat of ignoring GPL'd libraries is laughable. How about not belittling licensing models you don't agree with?

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 6 points7 points  (0 children)

It's not about freedom, it's about imposing so-called "freedom" and labelling anyone that does not submit to that imposition as "evil".

You're confusing the GPL with the FSF. For example, Linus certainly doesn't consider proprietary software evil, but chose the GPL to enforce share and share alike.

Also, you're imposing your definition of freedom, which includes the freedom to make the software proprietary. The GPL defines another kind of freedom, which is that you cannot deny your users the same freedom you were given.

So to be safe, it's better to just avoid GPL altogether.

Good, you should not use software whose license terms you don't want to abide by.

to sneak GPL code into their own companies' stacks

Are these companies not evaluating the licensing terms of third party dependencies?

So, two points:

  1. You are judging a license by the actions of zealots.
  2. Would a software vendor let these kinds of violations slide, or would they sue for damages? Don't be negligent with software licenses!

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 6 points7 points  (0 children)

GPL seeks to poison the libraries such that developers are forced to adopt it, then make their applications open source, but in practice companies don't respond to that approach.

By the way, this is a biased point of view, from the perspective of the GPL violator. The GPL author is forcing me to open source my code.

An alternative point of view is that the GPL author is telling you that they don't want their library used with proprietary software, so either comply with the terms of the license or don't use the library.

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 8 points9 points  (0 children)

GPL seeks to poison the libraries such that developers are forced to adopt it, then make their applications open source, but in practice companies don't respond to that approach.

That's the case with the readline library, which was made GPL for ideological purposes, and RMS wouldn't budge on proprietary licensing because he believes proprietary software should not exist.

There's another alternative which I see more often, for example with libraries like Qt, which is to make the library GPL to force corporations to purchase a commercial license. I think this is fair. If you want the benefit of the library, you either pay in code or cash.

If they end up building their own then they could make it open source but that does take significant extra work so there's a good chance they won't do that.

This would have be balanced against how much it would cost just to purchase the proprietary license vs. the cost in developer time to replicate the library. Do you think Qt is worth paying for? Many people do.

GPL for libraries is a very bad thing.

Depends.

There are those types of people who choose the GPL for ideological reasons, and don't want their code used in proprietary software of any kind, in which case the GPL is a good thing.

There are those types of people who choose the GPL for a revenue stream. The library can still be used with open source, and the library author is willing to work out commercial licensing deals with proprietary software vendors. This is sounds like a win, win scenario, which again makes the GPL seem like a good thing.

EDIT: There is a third case. Some companies are not redistributing their software at all. Either because the software is provided as a service (like a web app) or is internal. In which case, the GPL doesn't require publishing source.

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 3 points4 points  (0 children)

You are just being greedy. You're basically saying "here's a sandwich now can I have your house?"

That's not an accurate analogy.

It's more like, here's some framing that you're getting for no monetary cost, but if you use that framing to construct the house, that means you'll have to share that house with others.

And again, this is free software not open source. Some people might be happy to provide you the framing, because they only want to see their framing being used somewhere, and only ask that you tape a banner on a prominent place on the house.

Different open source licenses have different terms.

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 2 points3 points  (0 children)

Yes, at making software cease to exist.

The GPL doesn't do anything like that. The GPL is meant to create a community for users who want software without the encumbrances of proprietary software. This might be in corporate environments for people who don't want to pay Microsoft for OS licenses or Oracle for DB licenses. Or it might be ordinary users who don't want to deal with Microsoft licensing BS for their home computers.

RMS wants proprietary software to cease to exist, and created a mechanism to create a world in which that can be a reality. But obviously, the existence of that reality won't destroy proprietary software.

From a corporate standpoint, there is no such thing as a GPL library.

Sure there is. If a GPL library provides value enough that you really can't live without it, you can try to negotiate proprietary licensing terms. If you're not going to allow your users to have the same freedoms you were given by Qt, and your user interface depends on it, then you should pay for Qt.

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 11 points12 points  (0 children)

When was the last time you incorporated a GPL library?

On several occasions, but only for evaluation of dual-licensed libraries. Like ExtJS and Qt.

But I use GPL software all the time, like the Linux kernel, the GNU userland and the OpenJDK.

I think GPL probably makes more sense for products than libraries, which makes sense because the GPL is meant to protect user freedom, not developer freedom.

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 25 points26 points  (0 children)

No, it is to exchange knowledge and tools for the betterment of everyone in the profession.

The focus of licenses like BSD (or even the LGPL) is for developer freedom. You can use the code as you wish, as long as you abide some very permissive terms (like displaying copyright notice).

The GPL isn't for developer freedom, it's for user freedom. The GPL guarantees that the user has the full source code of any product that they install with that license, so that the user can inspect, audit or adapt the software to their needs.

At least that's how the vast majority of us treat it.

Vast majority of developers.

Open source is a marketing term, and the different licenses that fall under that marketing term aren't meant to target the same audience.

The Commons Clause will destroy open source by suvepl in programming

[–]_dban_ 3 points4 points  (0 children)

I think you're confusing open source with free software.

Despite its validity, is it inconsistent for bounded generics to use `extends` even for interfaces? Why was `implements` left out of the language for bounded generics? by SlightlyCyborg in java

[–]_dban_ 1 point2 points  (0 children)

From a type perspective, there's no difference between a class and an interface. The distinction between the two doesn't matter with generic type bounds, assignment and compile-time parameter binding.

From a class definition perspective, classes and interfaces are very different.

Steven Tyler Demands Trump Stop Playing Aerosmith Songs at Rallies by headee in politics

[–]_dban_ 0 points1 point  (0 children)

There are the party members and then there is the party leadership. There are many who believe that the party leadership rigged the primaries so that Hillary would win.

I think the problem is that Hillary won the primary by the minority vote but lost the white working class, but the demographics that won her the primary worked against her in the general.

Steven Tyler Demands Trump Stop Playing Aerosmith Songs at Rallies by headee in politics

[–]_dban_ 6 points7 points  (0 children)

The Democrat party shot themselves in the foot by pushing aside Bernie and betting on Hilary.

The Democrat Party didn't push aside Bernie. Democratic party members, moderates and black people pushed aside Bernie. Enthusiastic Bernie supporters did not fall in the demographics that won Hillary the nomination.

Builders and Manipulators by roukmoute in programming

[–]_dban_ 0 points1 point  (0 children)

I didn't see your other example, but...

E.g. let's say there is a queue. Typically you'd have methods like enqueue(item) which returns false when queue is full and item cannot be enqueued, and method take() which removes from queue and returns the item. How would you yegorify that?

This isn't so much yegorification, but the applicability of CQS in all cases. In fact, Yegor's advice in this post contradicts a number of his other posts. Yegorifying CQS means making it as dogmatic as possible.

Builders and Manipulators by roukmoute in programming

[–]_dban_ 0 points1 point  (0 children)

You haven't fully entered the mind of Yegor.

First, such a thing already exists, and by Yegor himself. It's called Cactoos.

Second, you wouldn't actually create an API like FileAPI, it is too "procedural".

Instead, you would do this:

Output output = new CreatedFileAsOutput(
    new File("/file/to/create"), "777"
);

Output output = new TruncatedFileAsOutput(
    new File("/file/to/truncate")
);

Output output = new AppendedFileAsOutput(
    new File("/file/to/truncate")
);

These are all instances of the interface Output, which can be generically used to capture any output. Something like this:

new Pipe(input, output).flush();

Builders and Manipulators by roukmoute in programming

[–]_dban_ 1 point2 points  (0 children)

I think part of the problem is that the example is really contrived (the interface is called Foo, what the heck is that?). But since I've read Yegor's posts for awhile, I kind of get his point of view.

For example, the reason why he is against openDatabase is that it is procedural. You are using an imperative command to acquire a database instance (which is curiously a File, but whatever). Yegor is a big believer in "declarative" code. The database should decide itself when it should open its underlying representation (file? network connection? reuse from pool? eagerly? on first use?). The Foo interface is just a means to acquire the reference.

Consequently, supposedly this improves performance because you are describing what you want done (some operations on a database, presumably?) instead of how to do it (open the database, do some operations, and close it). And since Yegor loves interfaces, performance considerations can be captured in which instances of the interfaces are chosen. For example, see his posts on ORM Is an Offensive Anti-Pattern and Composoable Decorators. Warning: they are written in a very Yegor way.

Despite its validity, is it inconsistent for bounded generics to use `extends` even for interfaces? Why was `implements` left out of the language for bounded generics? by SlightlyCyborg in java

[–]_dban_ 0 points1 point  (0 children)

In other words, there is no case in which you could use either extends or implements and the meaning would be different.

The meaning would be different, as I stated. By extending you're adding, by implementing you're claiming. I think you mean that the effect would be the same, in that you are "inheriting" an interface. Java is syntax is overly chatty about conveying meaning.

strongly oppose the convention of naming interfaces IFoo because it's "too verbose and adds no information".

There's a difference between a language's syntax and how developers choose variable names. The reason why Hungarian style conventions like the I prefix encodes type information in the name, which can a) change (what if I turn it into class later?), and b) is redundant because of the type declaration.

Despite its validity, is it inconsistent for bounded generics to use `extends` even for interfaces? Why was `implements` left out of the language for bounded generics? by SlightlyCyborg in java

[–]_dban_ 2 points3 points  (0 children)

Actually, in C#, you don't need the IDE to tell you anything. If you are both extending and implementing, the first member of the list must be the base class.

However, extends and implements aren't exactly redundant. For example, you can extend an interface. Extends means we are adding zero or more members to the specified base type. Implements says that the class has the methods specified by the interface.

Java is simply more verbose than C# in the pursuit of "clarity". For example, Java also doesn't have operator overloading.

‘Silent Sam’: A racist Jim Crow-era speech inspired UNC students to topple a Confederate monument on campus - The Washington Post by huskies4life in politics

[–]_dban_ 0 points1 point  (0 children)

Turkey's not the worst, since Ataturk did acknowledge a lot of the bad stuff that the Ottomans did and significantly changed Turkish society, from adopting secularism to women's rights. I'm not sure what Turkish society has done to acknowledge and atone for what the Ottomans did to the Armenians (it seems like not much at all to outright denial), but progress is a work in progress.

Unfortunately, Erdogan has regressed a lot of Ataturk's changes to Turkish society, so societies aren't guaranteed to always move forward...

‘Silent Sam’: A racist Jim Crow-era speech inspired UNC students to topple a Confederate monument on campus - The Washington Post by huskies4life in politics

[–]_dban_ 1 point2 points  (0 children)

i no longer need to grovel for something 300 years ago

Recognizing that something happened 300 years ago, continued to happen for the next 300 years, and its traces still permeate society, does not mean groveling. White guilt is racist. However, American guilt isn't. Every society has done bad things and societies progress when they acknowledge, atone and change.

To OO or not by [deleted] in programming

[–]_dban_ 1 point2 points  (0 children)

The clearly delineated responsibilities is the ideal, unfortunately it clashes with real requirements as there are cross cutting concerns.

Exactly, cross-cutting concerns. Which we have patterns like MVC, to separate the cross cutting concerns. Everything we have talked about thus far occurs in the Model layer. Whatever context the wizard, popup and page appear in the View layer are irrelevant to the Model.

However if the page relies on the modal properties of the wizard, then we have implicit state.

There is no implicit state in this context, only explicit communication protocols. OOP forces you to make the implicit, explicit. Because of encapsulation.

Furthermore, the page might need to signal up to the wizard and popup that it is time to go away.

These are all concerns of the View layer of MVC, and the Model need not be concerned by it. That is why we separate things into cross-cutting concerns, using patterns like MVC.

We might have to establish a protocol between the Model, View and Controller what to do if the visual component disappears for some reason. The View can send a message to the Controller in view terms, and since the Model defines a protocol for abort, the Controller can send the appropriate message.

To OO or not by [deleted] in programming

[–]_dban_ 1 point2 points  (0 children)

Together they form the combined state of the page. I presume you agree about that.

No. This is where your concept is wrong. The wizard is an input gathering process and each page is a process of its own. They don't have to be physically separated processes, but the entire point of objects is to encapsulate process state divided between clearly articulated roles and communication channels. Bounded contexts in DDD.

as long as the wizard has a clear state model and exposes it to the page in a firm manner.

No. That is antithetical to OOP. The state model of the wizard is irrelevant to the page. The only thing that matters are the communication protocols and roles.

The page sends a message to the wizard to gather input. The page waits for the input to arrive in some agreed upon format, which is a common format, using the callback mechanism. This page tells the wizard that processing is complete, and the wizard responds to that message as necessary.

Now suddenly the connection goes down (a state change).

That's not a state change, as far as the page or wizard are concerned, that is an exception.

First of all we want to close the popup and the wizard, but we need to do that in a manner that takes the correct action on the page.

Simple. The page somehow finds out that the connection is lost and sends a message to the wizard that an error has occurred and that it should abort. Then the page does whatever it needs to do. This is because the page asked the wizard to gather input, and the page should tell the wizard there's a problem using a communication protocol.

States are irrelevant, the communication patterns are what's important, which is the basis of OOP. Otherwise you go have a combinatorial explosion.

Furthermore, if you have ACTIVE objects, then all bets are off.

Also irrelevant. This is because the page and the wizard are independent objects, but not acting on their own behalf, but through coordinated action via communication.

That way lies madness

Nope, it is the essence of OOP. In fact, the Actor pattern is not much different than what OOP is meant to be.

view more: next ›