cbdfghh

EE is open source

It is _not_. You cannot distribute it. That makes it not open source.

So what's the advantage of using Android over straight Linux?

Just curious, is a Go string a C string inside (rune array + nil) or a proper class array?

In other words, in

a:="b"+"c"

IOW, does it implement the Slemiel's painting algorithm or not?

Hasn't happened. Won't happen.

I don't know about five years. But in 25 I don't know if you'll be able to differentiate your computer from your (old, dumb) TV, except you'll have fewer rights

Not everywhere. CA, for example, doesn't permit them.

But companies also have non-compete (or other exclusionary) clauses which are legal outside of anti-trust laws.

employees weren't allowed to quit

In the US you can quit and look for another job, the same way how MS can exit the OS market.

The same way MS doesn't leave the OS market (too lucrative), most people don't walk off on their jobs.

The issue is that US workers now compete with the whole world.

Until the 70s, the US really had no competition. To compete, you need a stable (legal) system - No one would invest money in a country where it's not far-fetched that someone will overthrow the government, nationalizes your company and throws you in jail.

Oh, and because of geo-politics, one couldn't invest in USSR friendly countries (both from the US side and the other side)

So no one would invest in the USSR, Africa, the Middle East, China or India, Europe and Japan were in shambles. So who built up industry? The US.

After the 60s, different countries started stabilizing. First Japan, then China, now most of the world is actually quite stable, so now the average US worker has to compete against all of India, China, Bangladesh, etc.

You have more supply and the same demand (the world).

And the problem is nothing can really be done about it.

It's like employers don't even attempt to think about anything from the employee's perspective -- even after they've struggled to fill their own positions. "Cheap business owners" couldn't be a more accurate byline.

Or maybe the job their trying to fill isn't worth that much to them (the employers, that is)?

As an example, let's take a speech-writer for a presidential candidate.

Company X (let's say it has 100 billion in the bank) wants a website, so it looks for an SEO firm, but it's cheap and not interested in investing in the website.

X doesn't get skilled SEO consultants.

X now has three choices - get minimum quality workers, drop the website project or pay more for better workers.

Obviously, workers would prefer if X choses 3, but there are times when it just doesn't make sense to do so (or the company doesn't _think_ it needs to do so, and goes out of business):

What if a company has a small audience comprised of people who don't find things online.

Let's say the company runs a program only senators would use. That's a hundred person market which practically requires personal connection to their staff to make a deal.

Hiring someone for $250,000 website is just not worth it.

Practically, in a capitalist environment, workers are "contractors" selling themselves.

The same way I would not pay for a big-iron computer when all I need is a laptop, companies don't want to pay $200,000 when they can find someone for less.

Would it be possible to take ebay to a small claims court?

In a library, breaking releases should be far fewer than "regular" feature releases. My point is that if you break code more than a few times in the history of your library, you'll get a revolution. For example, see Python 2->3, which was a relatively "small" fix (which just happened to affect pretty much half of existing string processing code), and PHP, where they seem to introduce and then turn around and remove those features every couple years (mysql, no, mysqli, no, PDO? Are we there yet?)

The point of Semantic Versioning is to tell you something.

So let's say you have Compiler 5.3.2

It means that the important thing is compiler #5. Upgrading from 4 to 5 is a _Big Deal_. You may have to rewrite all your code.

Within 5, you have a version 3. 3 has features A,B,C which 2 doesn't have. Most additions go there. So it should be safe to upgrade.

Within that, you have bugfix #2. That _should_ always be upgraded, unless you rely on undocumented features.

So it's easy for me to tell if I should upgrade.

So upgrading from Apache 1 to Apache 2 may brake config scripts and .htaccess files. Don't upgrade on production build.

Upgrading Apache 1.1 to 1.2, See README, Should be fine, do a small test on your testing machine.

Upgrading Apache 1.1.2 to 1.1.3. Probably a security fix. Do so. Immediately.

---------

The OP's numbering system doesn't tell me anything. should I upgrade 5.4.3.2 to 5.5.0.0? Will it be safe? Probably not. You may have to schedule a full testing load just to be sure.

What about from 5.4.3.2 to 6.4.0.0? Same thing. You have to do a full testing.

And if you _really_ break old code, do everyone a favor and rename your project (So, no, please don't call Go C++ V.13 or something)

If you're using a proper type-safe compiled language then most "subtle" breaking changes can't possibly be missed because your code won't compile anymore (assuming you used that API to begin with). You don't need a major version number to call attention to the fact that one parameter of one method changed from a boolean flag to a set of options, anyone who's using that method will find that out pretty quickly.

1. What if it's a dll, .so? You upgrade and find out that your program is broken.

2. Sometimes the API stays the same but the code behind the API changes a result (for example, secure_hash goes from MD5 to bcrypt)?

3. What about non-type safe languages (like HTML or JS, so things like Firefox or Chrome)?

The point is that you should avoid breaking other people's code if you can. What happened if that removal of one function in that one module costs me a full years of work?

Sometimes you can't help yourself. PHP had register_globals. Some people were able to use it safely (initialize all variables before use), but PHP rightfully realized the security implications and disabled it. However, it broke code, and a lot of it.

These are things you should think about and heavily before breaking code. It may be one line for you, but for all the millions of people who use your library it could be thousands of man-years of work.

I like the idea of Semantic Versioning, but it does cause problems where if I'm going to do several breaking releases one after another I have to keep bumping the major version, and I hate that. I've actually put off doing breaking changes simply because I didn't want to bump the major version number, but I don't like that either.

When you're doing backend/API things (where breaking changes matter), I sure hope you think a million times before making breaking changes.

Can you imagine if someone had to go through millions of lines of his code to make sure nothing broke, then, a week later, you broke his code again?

There's a reason why the project name doesn't change just because you bumped the major version number.

The OP suggested to make an "evergreen" Angular, like an evergreen Chrome. My point is that you can't do that if you introduce breaking changes, because "this will work in C (and just upgrade to a new version if you don't have it)" doesn't work anymore.

Obviously making small breaking changes shouldn't require renaming your language (so PHP4 is still PHP, even though it broke quite a lot of old files relying on register_globals)

It's much more reasonable though: they're committed to using Semver, so even a minor breaking change (like upgrading Typescript) will bump the version number. So they're expecting the version numbers not to matter as much anymore, similar to how you no longer think of the version number of Chrome or Firefox too often.

That's contradictory.

Once you introduce breaking changes, you require people to update, and old code may not work on new systems.

Then you can't just say "Angular" like you can't say "Python" or "C/C++"

I'm not comparing directly, but I want to put our "moral outrage" in perspective.

This was the 1700s. People were living on subsistence farming. If you weren't a landowner in England, you starved, and it wasn't like in 2016 where there's realistic talk of UBI based on automation, I mean it was like over a hundred years before Marx, and long before the industrial revolution.

And it's not like the "wealthy" were so terribly wealthy that they could just take "free" people to America.

And it's also not like the wealthy had nice 1890's first class ship rides.

The times were terrible, and the choices were terrible.

Well, what do we have nowadays?

Want a house? Be a slave to Microsoft for forty years!

Want to eat? Be a slave to Google!

The poor were more than welcome to stay in England or Germany, it's not like they were kidnapped or anything.

And as far as conditions go, sure, nowadays such trips would be illegal, but how much worse was it than a payed for trip?

Don't forget than if someone died on the trip, the captain lost money.

If you don't want to get hacked by visiting a website, use cURL (actually, I think it had a few security bugs, so...)

The difference is that websites have rep, and google polices sites with malware protection (which firefox uses too, btw).

What about ads?

That's also true.

Sometimes I suspect the main programmers for Apache2/BSD/MIT licensed works actually hope their works get used by the big guys so they can get employment there.

That's why I've never heard any BSD guys getting upset at MS for ripping off their work, while getting upset at Linux for doing the same.

I've been thinking more and more about how Stallman has blocked perhaps the only effective way to make companies make more open-source software: allow DRM to work properly with open-source code.

That's a feature, not a bug.

He's not interested in creating a "commons" for companies.

He's interested in having his code help users, and create an incentive for companies to create code which will help users.

If you look at it from that perspective, with DRM you might as well be closed source.

-----------

Oh. And DRM encumbered code is arguably closed source.

Imagine a license - You can copy and distribute source, compile source, but not use your compiled binaries.

That wouldn't fit either the OSS or FSF definition of Open Source/Free Software.

But that's what DRM does. It effectively says that you cannot run this software on your devise.

Personally, I find people complaining about the GPL's lack of freedom a bit hypocritical.

What does the GPL prevent you from doing?

As a user, nothing. As far as I (a user) is concerned, Mozilla's MPL/GPL, bash's GPL3 and VSCode MIT licenses are all equally free (I can use them and distribute them).

So what problem do programmers have with GPL?

You can't make a derivative closed source work.

So you want to make a non-free work, fine. I'm not a GPL-or-bust guy.

But are _your_ programs free?

IMHO, Stallman made two mistakes:

1. He moved into politics (which is in my HO, one of the failure points of a lot of tech people. Everyone has a right to an opinion, but certain people have more talent at politics than others, and certain people have more talents at code than others).

He's a great programmer, and could have pushed the FSF community directly by committing and improving code. And even if he can't code anymore, he could have focused on fund-raising/raising awareness in winnable (as in, not facebook)/worthwhile (as in, not HURD) battles, where others would benefit also.

Like a free Flash or free CAD (which are "FSF High priority projects", though practically dead).

What new coding projects were they involved in since HURD started (OK. Replicant.)?

And how did his political rants help the FSF (and the Free Software movement as a whole) lately?

2. He doesn't let the FSF be larger than him.

Who's their 2nd in command?

Who'll take over after he passes on?

What will the FSF look like in 30 years?

You're talking about rooting the phone, I guess you want /etc/hosts or something, but you know, even on the desktop that kind of solution requires sudo rights. This one is entirely about security and really, Android is not that hard to root.

You don't have to root your phone. You can install an Open Source VPS app which filters ads, no root required (and data stays on your phone).

What I would personally like (and I'm kind of surprised all projects which tried to implement it died) is a Java -> static exe/elf compiler (sort of like Go) or at least java -> exe/elf +libjava.so .

I hate that deploying Java requires that everything has to be configured _exactly_ right, and write once run anywhere turns into write once debug everywhere.

OpenSSL uses assembly not for speed but for security. You need to make sure algorithms don't "optimize" leaking data.

For example, a strcmp on a secret field is insecure because of timing attacks.

The only way to ensure the CPU takes a fixed amount of time is through assembler

After all, corporations are people right

Except they're not, and no one says they are.

All the court said was that groups of people don't lose rights they have as individuals.

So if A has right X B has right X C has right X

then A+B+C have right X

The solution is very simple.

Google's spider uses headless chrome which runs Javascript (to index flash and Ajax content). Why can't they detect how long it takes to run your page before getting useful content?

What about just penalizing Javascript?

What about penalizing download size?