pksadiq

I myself use org-mode on my system. On my phone I use orgzly[0] which may be worth looking.

[0] https://github.com/orgzly/orgzly-android

> I plan ....

I would recommend you to write these plans in a notebook (real notebook with pen/pencil). Write all of your plans, whenever you plan. The problem with software solutions is that once you reschedule, its history is lost.

I have such a book which has now almost run out of pages. Once a week I read them. Most of them are not yet done. But it makes me feel good, and helps me prioritize better than software solutions.

> No seriously, how do you keep the browser from hooking you?

This was a really big issue with me too. What I did in the past was to signup for low bandwidth internet connection (not by speed, but with yearly limit of 18 GiB), which made me limit the frequent visits.

These days when I do some serious work, I decides to disconnect internet for the next 45 minutes (or so). I have locally installed manpages, devhelp and devdocs.io documentations. Even if I'm tempted to visit some website (eg: stackoverflow), I delay until the time reaches.

> Complain to the recruiter afterwards, if they bother calling you, but make sure you tell them that the particular interviewer was not good.

That would be a bad idea. The recruiter knows nothing about the OP, and probably not much about the interviewer. But the recruiter probably will be in better terms with the interviewer than the OP (or the one who is being interviewed).

So the end result would be that the OP will be considered not a good candidate because he/she complains the interviewer because it didn't went well, or at least, that will be how the recruiter is probably going to assume.

Is your signup form felt like phishing?

Its title is "SievePRO Onboarding (copy)" and it asks for all credit card details rather than forwarding to some payment gateway.

> It is mostly users, not developers, who don't care about binary blobs.

Partly yes, but mostly No.

You are right that most people don't care about binary blobs. But the people who can enforce this are the developers. If all developers agree and enforce this, no on can include binary blobs in Linux kernel.

Also it would be wrong for a mere user to try to enforce it by law, because it might piss off the developers, which is really bad. Also, it might not withstand in court because the developers don't care.

> The users then take the "pragmatic" approach of using binary blobs, but hey, stuff works for them.

"pragmatic"? Most of us are concerned about our immediate problems, and thus we end up with temporary solutions (most of the time), sometimes because we don't have choice, sometimes because that's easier.

I recently got an ASUS eeepc which doesn't have graphics support, because when it was first released, the only support was a binary blob, which is now abandoned.

We will eventually face issues with these binary blobs, for sure. As we know, each day, new vulnerabilities are being surfaced.

But yeah, most of us won't care, until and unless something happen. But by then, it will be too late. Just like how many of us consider the importance of time only when we know we don't have enough.

So I don't think it is "pragmatic" in long term.

> glibc is LGPL, so I don't see how that should change anything?

glibc requires libgcc[0], which is GPLv3 (with runtime exception). The same for libstdc++[1].

[0] https://gcc.gnu.org/onlinedocs/gccint/Libgcc.html [1] https://gcc.gnu.org/onlinedocs/libstdc++/manual/license.html

> That's not true, as the Linux kernel is still GPLv2. So while you could swap out the userspace GNU utils, the device manufacturer can still lock the bootloader which is perfectly fine with the GPLv2.

Yeah, probably. But the presence of packages like GNU libc can make it harder for the manufacturer to lock the device.

> ... kernel version due to proprietary binary blobs which nearly every phone uses.

Sadly, binary blobs are always an issue. In the case of Linux, this happened because many Linux developers don't care about binary blobs. If they did, you won't see any binary blobs (as it is a violation of GNU GPL).

> ... with complete open source drivers

My main point was to quote that 'open source' doesn't solve these issues. We should take software freedom more seriously.

> ... (or a GPLv3 kernel).

I wish we will not have to wait until the human civilization end in fire to see this.

> That's one reason I'm still hoping for a Linux/Firefox phone.

You should rather hope for GNU/Linux phones. Linux devices (without the GNU part) is most of the time, just another locked device (see your Android phone, router, TV, etc).

The presence of GNU software pieces (or any software licensed under GNU [LA]GPL v3+) ensures the device is free of locks (or with user breakable locks).

> Nobody smart enough to design that system is dumb enough no not understand the consequences.

Do you remember the plain text password leaks from Yahoo? In the real world nothing has to be true/good/secure. All it has to be is that users should be felt so, doesn't matter what the reality is.

As long as the focus is on earning more money/power/control, this is always going to happen.

> If it was something done for the CIA, I believe it would probably have been kept secret instead of marketed.

If that is the case, we would have doubted about this too much early than it would otherwise (because there is a dedicated hardware).

So some people friendly feature have to be dubbed along with the anti-features. This may not be the real case though, but one of the possibilities.

> I unplugged the microphone on my daughter's iMac years ago.

Please note that a speaker may also act as a microphone if configured so (at software level). This is especially true for speakers/headphones connected via the jack.

I have had issues with impress.js when my laptop's resolution was different from the projector's.

There is an Emacs org-reveal[0] package that shall help you use it like WYSIWYG.

[0] https://github.com/yjwen/org-reveal/

I tried this Emacs for org-mode. It was not that good experience. Very recently I found orgzly[0]. It might be interesting for you too.

[0] https://github.com/orgzly/orgzly-android

> And if you forget your password, or lose your hardware login keys, you'll have to jump through more hoops than ever to regain access ...

'Advanced Protection'?

In any case, if passwords can be reset and if USB keys can be changed, there is always a flaw... No matter what Google say.

> ... your license to wear the shirt is revoked.

Well, you have 30 days time to comply.

> Basically only those rich enough to buy Google devices every three years.

Or when you buy a phone buy a phone that supports Lineage OS. My Samsung Galaxy S2 runs an up to date Lineage OS.

> Are you saying that GPLv2, which was created by the FSF and is used by such prominent projects as the Linux kernel, is not Free Software?

No. I have quoted that in a comment below. That is, a software can be both open source and free software or open source only based on where the code is run. GNU GPLv3 simply enforces this freedom irrespective of where the code is run. That doesn't mean some other license is non-free.

> Stop speaking nonsense.

We learn from mistakes. And from the mistakes we made, we learn and improve. GNU GPLv2 wasn't a mistake. It was a really good License (still is). But time proved its weakness. And FSF released GPL v3 License that addressed many issues that weren't addressed by GPL v2.

FSF now recommends GNU [LA]GPLv3 for most of the software pieces. So yeah, a binary of a code written in GNU GPLv2 may become non-free (but still open source), but GNU GPLv3 code and binary will always be free software (until time proves otherwise).

Edit: clarify that the binary made with GNU GPLv2 code (not to be confused with the source code itself) may be non-free.

> Where in The Free Software Definition https://www.gnu.org/philosophy/free-sw.en.html does it require the user to be able to run the modified versions on the same device?

Quoting from the above link:

Freedom 1 includes the freedom to use your changed version in place of the original. If the program is delivered in a product designed to run someone else's modified versions but refuse to run yours — a practice known as “tivoization” or “lockdown”, or (in its practitioners' perverse terminology) as “secure boot” — freedom 1 becomes an empty pretense rather than a practical reality. These binaries are not free software even if the source code they are compiled from is free.

>> You get the source code of those, but you may not be able to change them.

> Yes you can. See https://opensource.org/osd-annotated

Well. I have explained about that in the above comment. I'm not saying that you can't modify the source. But open source software don't require the user to be able to run the modified versions on the same device, free software do.

So the same software can be both free software and open source or open source only based on where the code is run.

> The difference is merely a philosophical one

NO. They can be very different practically.

For example, your Android phone/router contains open source software pieces (and very likely have GPLv2 licensed code). You get the source code of those, but you may not be able to change them. So yes, they are open source, but not free software.

Open source means the code is open, and you can do anything with the code (licensing restrictions implied). Free software extends that further to have freedom to run modified code on the same device[0] (See freedom 1 and its explanation: The freedom to study how the program works, and change it so it does your computing as you wish). This is a very important distinction between free software and open source software.

This was one of the primary reasons why GNU GPLv3 was introduced.

So in many occasions, open source != free software.

[0]https://www.gnu.org/philosophy/free-sw.en.html

btw, this would work with slightly older rm from GNU coreutils:

  rm -rf --n /

any GNU long option (getopt_long) for any command can be shortened as much as there isn't any ambiguity. And hence the above (this is fixed in latest GNU coreutils release).

No. But as ddwrt and openwrt source codes are already available in public, people may not be interested (because you are not going to get the source of binary-blobs in any case, blame Linus Torvalds for that).

I have found a person that requested source of BMW i3 car software, and he have uploaded the source online[0].

[0] https://github.com/edent/BMW-OpenSource

> You only have to give code to the user after purchase.

IANAL.

You don't really require to give the source code unless the purchased person asks for the source. Most people don't care about the source. And you require only to provide source for people who obtained the binary legally. Nobody else can demand for source code.

Say for example, most of the D-Link routers come with a warranty card saying the software is GPL and is available on request. Period.

You can also void the warranty of the software (and hardware) in case the software you sold was replaced with a modified version (afaik, requesting for source can't make the warranty void).

There are a few things to consider: GPL v2 requires you to produce the source code in CD/Floppy (or like media), while GPL v3 allows you to have the source uploaded to net (or sent via email).

eh.. Why do manufacturers speak mAh instead of watts??

people get very annoyed when they know what that really means. Say for example, every power bank available says 10,000 mAh, or 20,000 mAh (or whatever), but all those are at 3.6 volts (not at 5 volts). As most of the other specs is in 5 volts, most people don't even know this.

> Present != Equal, feature wise.

It is developed by google[0] afaik. The link says it is present in LLVM and gcc. I don't know what makes the difference (may be License?). On the contrary I have felt gcc better for my work. I have been following a clang bug[1] for long and have seen no fix so far.

[0] https://github.com/google/sanitizers/wiki/AddressSanitizer

[1] https://bugs.llvm.org/show_bug.cgi?id=23910

Those sanitizers are present in gcc too[0].

[0] https://gcc.gnu.org/onlinedocs/gcc/Instrumentation-Options.h...

Status is also updated at twitter[0].

[0] https://twitter.com/gitlabstatus

> Microsoft has publicly stated that Windows 10 will be the last product in the Windows line.

This may be because:

  1. Cloud is where the money is.
  2. Maintaining an OS is a lot of burden (Hardware drivers,
  patents, tie ups with several hardware/software vendors,
  developer cost, and so on)

So the simple thing they can consider is to ditch the OS, and develop platform independent solutions. Gradually this will (hopefully) happen.

Releasing the OS source will be too much costly (cleaning back doors, lots of code smell, and so on). This will cause too many people vulnerable to attacks. And that can't happen.

So no, Windows won't go open source.