[0] - https://marc.info/?l=openbsd-tech&m=153504937925732
(edit: words)
740 karma · joined April 1, 2016
[0] - https://marc.info/?l=openbsd-tech&m=153504937925732
(edit: words)
But I hardly ever used Chrome, and wasn't signed in when using Google most of the time. I suspect they don't have a complete profile to improve their results.
Still I would take somewhat worse search results over handing out all of my web usage any day :)
That's not exactly true. Both companies have shown that they _will_ switch to selling something different when they believe they can make more money that way.
Also, both these companies spy on you while using their products, and both sell that data to their advertisers. It's not just Google.
You should use both their products as you want, when they help you. My point is mainly not to trust that the company behind the developer products is some kind of a good actor. They will sell you out when it fits them.
That was in February 2017 [0]. Not exactly recently IMO.
I recall that Github also had data loss and scaling issues back when they were starting up. Those days are now gone for them though.
[0] - https://about.gitlab.com/2017/02/01/gitlab-dot-com-database-...
This is what people said about Google too a few years back.
The reality is: Everything they're doing is designed to increase the company value for their shareholders.
Using a different license on the exact same code withoit consent is very different from linking to that code respeciting its original license.
> going from MIT to GPL is fine, but GPL to MIT is not
AFAIK both are _not_ fine, eapecially because the licenses are totally incompatible.
When you publish a patch under a certain license (that of the project at the moment of the contribution), you _only_ allow using your code under that license. This is why dual licensing is a thing.
Except when you sign a CLA - mostly used by companies to gain copyright over your work. In that case the company can do whatever they want - even charge you later to use your own code.
> open source is always better than proprietary
I don’t think anyone has ever claimed this. But for people ( like me) who care about their freedom, it’s mostly a small sacrifice you can make to retain freedom. I find the latter is more important, not that OSS is _better_.
They are also the only possibilities to provide proper end-to-end encryption. The last thing we need is another proprietary “standard” (remember how those same companies pushed for drm in the w3c spec).
Yet the only real change can come when end users understand the implications of using the free email providers. I think this is harder for most than using a pgp email client plugin.
Let me make another suggestion: nixpkgs [0] it helps to define exactly that fixed set of dependencies. Not just on published version number, but on the actual source code _and_ all it's dependencies.
To use this I must give a webapp access to my spotify account. That’s a no go for me.
I tend to take my business away from vendors who pull this kind of crap.
It's not because Google has open sourced Android (which they _had_ to because of the GPL used by Linux). The fine is for protecting their own marker by blocking others from using that open source software.
I agree that this is all good practice and helps prevent common classes of bugs. Obviously it will also safe you time of debugging these.
But your stack doesn't end at your code. There's a whole bunch of other code yours is linked to, there might be an interpreter or vm, there's the OS, the kernel and firmware. So IMO it's a bit naive to say you don't need debugging tools/skills.
I'd say it depends. I find that TDD works mostly as the complement to a good type checker. It is extremely useful when the PL has weak or no type checking (eg javascript, ruby, python, c, etc).
I’m on the same path as GP, terrified that my MBP 2015 breaks. However, it will be my last mac. I’m fed up with apple’s bs when it comes to their pro laptops.
(edit: spelling)
Sorry but when you lack all basic computer skills, you should _not_ be setting up TLS for a web server. No matter if you use Cloudflare or something else, have someone else do it.
And then what? This only works if you can eliminate the "choice" altogether. Otherwise the "choice" still will be encoded if your system, be it much less obvious.
Think using null/nil instead of an optional type. Now everywhere you use the value (including when passed to other functions) you have to test the value for not being null. With a proper ADT (Maybe, Optional, what you prefer) it is obvious when you have a value and when you don't know.
As a matter of fact it does. Polymorphisms come in many forms (pun intended). The OO-pattern of class inheritance is simply just one of them - not quite so good too if you ask me :)
The author seems to believe that polymorphism is OO-specific. But it isn't. As a matter of fact, if/switch statements are _also_ polymorphic, often used in more procedural code.
The more functional way to match on different type constructors is a fine example of a polymorphic function.
Then I find Firefox better than Chrome when both run with or without extensions.
Only time will tell.
Personally I'm not that grateful to Google. Like you said, it all started out as a good thing - rather innocent. And of course it turned to "profit at all cost" soon after that.
IMHO most people not quite understand the trade-offs involving technology choice. Large companies like Google, Microsoft, Apple (in no particular order) take advantage of that in the interest of their stakeholders. Violating their user's freedom and privacy along the way.
That happens. It doesn't need to a standard format like that however. Some command like tools add a porcelain option that produces output for scripting (ie no ansi color codes, easy to parse, etc). That works well too.
This has nothing to do with being a "compiled" language, nor with being a statically types language for that matter.
If languages like Haskell and Idris can have a repl, very basic languages like Crystal certainly can. I can imagine it not being their top priority though.
I just want to add that if you have to parse command output, enforce the output format as well as you can. The --verbose bug really shouldn’t have happened.
While I sympathize with this, I would like ORMs to make it a lot harder to make these mistakes.
Especially frameworks for dynamic languages (in my experience) have performance issues by default (and when following their docs). That should probably change.
I believe it still did when Gitlab started
This is as much true as it is for developers of proprietary software.
There are many examples on both sides that make your statement false, also as many to make it true.