I doubt the information is really anonymized in the first place. Making it really anonymous requires will, skill, incentive, hierarchical validation and resources. Not doing it on the other hand, is the path of least resistance. Plus the last 2 decades have proven you can not only get away with it, but people calling you on it have a high chance of paying the price for it.
> website.example will be marked for non-cookie website data deletion if the user is navigated from a domain classified with cross-site tracking capabilities to a final URL with a query string and/or a fragment identifier, such as website.example?clickID=0123456789.
So my guess is you are fine most of the time, except if you allow other sites to embed your content in their page. In that case, you should:
- provide the embed on a separate subdomain
- remove features requiring identification if the content is view embedded: attempting to use them redirect to the real site.
Otherwise ITP will mark your domain as tracking and wipe you after 7 days if your user don't interact directly with the site.
I have a hard time deciding if it's a good thing or not.
I guess it has the potential to be mostly a good thing, provided that:
- I understood it correctly, which I'm not sure, as their wording is not clear
- It's implemented correctly. Once the deal is done, it's in the wild years, fix or not.
- It's implemented in good faith. Apple wants to promote the app store and has shown to neuter web apps in the past.
JWT tokens are irrevocable by design, or it would defeat the purpose. I would advise against issuing JWT token which are long-lived. Using "refresh tokens" are generally more prefered, as this gives an opportunity to revoke a stolen token in active use by the attacker. Even 7 days seems like an excessively large session time. That is 7 days a stolen token can be used to forge an authenticated session.
My guess would be that if your user uses service site.com, calling using microservice micro.com, then you have to store the JWT in the localstorage of site.com, but cannot store it on the localStorage of micro.com.
Take any century in the last 2000 years of human history, and there are files about people. For long it was sculpted or hand written. Then it was printed. Now it's digital. But it's the same thing, only the scale and speed change.
And at any point during those centuries, somewhere in the world, some entity (it doesn't have to be the gov) does bad things with those files. It's different every time. Excluding, killing, tracking, stealing, controlling... The form changes every time, but it's the same thing: abuse of those files.
It would, of course, be less of a problem if the information access was perfectly symmetrical. If anybody could access anybody's data, society would probably have a hard time for a few years, then adjust. And maybe become more fair.
But that's not what's happening. Here it just reinforces power asymmetry. And it creates incentives with huge bias that affect everybody's life.
There are three reasons why people give your answer.
1 - We had a nice run for a few decades in North America and West Europe. It's been a sweet life. And the human mind sets it as a new baseline. Now people see this as normal, and something else as the exception.
However, those decades ARE the exception. An exception that needs maintenance to preserve as best as we can.
2 - We are already pretty bad at making the connection between our misery today and the consequences of our past lifestyle, but today's information system is making it extra hard.
There are several factors for this: those in power getting really good at PR, information overload, more levels of indirection between causes and consequences, and the whole system complexity that never ceases to increase.
3 - The convenience is huge, and the price delayed
We don't get tracked for free, we get huge convenience in exchange. Plus we don't pay the price immediately, nor individually. We pay it as a society, and since it's cumulative, it's not obvious how much it costs us. It will only be painful in ... Well nobody knows when.
In fact, not only doing things right would rip us from convenience, but we would individually pay a strong price on top, right now. While seeing everybody around not doing it.
It's the exact same problem than for global warming.
Not accepting tracking is a deep and important political decision that shapes the future of our entire society. It is as important as avoiding mixing the church and the state or defending freedom of speech.
And it's also why it's not a popular view: it requires to think about what society we want to build, and not just what life we hope to have individually.
Yeah I should clarify; I think it's well past the time of sh.
Still, sh is unrivaled for portability and brevity/velocity; I wouldn't swap virtually any the shell scripts I've written for python scripts. I think sh is a decent and often well-suited tool if you can manage to wield it properly (not a straightforward endeavor).
I look forward to checking out oilshell though, so thank you~
Edit: FWIW for arrays in POSIX sh I generally only use:
With JS being the better way, why would people chose that over, say, Vue ? For a few ko you can do that and more. And transition to a full scale infra if needed later.
I'm hopping someday people will provide a friendly Python API on top of ansible so that I don't have to write its YAML DSL anymore.
The "it must be idempotent" argument lead to putting conditional into a a language that was never meant to be, doing the whole "store" danse that could be done with simple function calls and whole lot of conventions instead of a proof tested import system.
It's calling python code behind the scene anyway, and nothing reads the playbook apart from ansible itself.
Ansible is a great tool, but I strongly believe the experience would be 100% better without learning, crafting and debugging those twisted .yml.
> It's calling python code behind the scene anyway
It doesn't even really do that. It sets up a rube goldberg mechanism to push a python program containing a base64 encoded zip file containing the module it wants to execute it. Then it runs a shell to run python to run that module. This is why ansible is 2000x slower than it should be.
Mitogen is a nice speedup if it works for your use case. Some of the improvements from the mitogen architecture have slowly worked their way into Ansible core, but it seems that a number of the major shifts can lead to breakage in some scenarios. Hopefully more of the low hanging fruit can make it into Ansible someday...
I have no idea. AFAICT these were developed because some people found Ansible too limiting, so instead of the 'narrowness' of Ansible modules you can program just about any behaviour you want.
However, I've said this many times before—if your playbooks start mixing Python into tasks, you're either doing something wrong (it could be architected better), or it's time to write a custom Ansible module so the Python goes into a `.py` file and not into YAML.
99% of my playbooks are strict YAML with maybe a few Jinja filters, which make everything very readable. But I've also seen a ton of YAML that makes me want to barf.
from icandream import playbook
pb = playbook("Hello Ansible", hosts=["ansibleclient01.local"])
with db.define_task(Copy '/tmp/testfile.txt' into 'hello world') as task:
task.copy(content="hello worldn", dest="/tmp/testfile.txt)
Instant benefits:
- Python interpretter is very good at telling you error messages.
- You get an exception system, stack trace and a debugger for free
- The entire python tooling ecosystem, including full monthy IDE support, linters and formaters, is at your disposal
- Any more complex example is going to be much cleaner than the yaml version, exponentially. And no need to live in the "yaml/python module" dichotomy to keep PB clean.
- No need to reinvent the wheel. Python has elegant import, namespaces, ways to pass data around, conditionals, etc.,
- You can import Python libs. Event if it's just for declarative stuff like pendulum, appdirs..
The only cons are:
- idempotence needs to be enforced culturally. It's already the case for people writing the module behind the scene, and a good API + some warning tricks would be enough IMO.
- can't read the files outside of Python. But nobody does it anyway, and we can always let the Python files output the yaml representation if needed.
Now I don't hold my breath because it's a lot of work and the ansible community usually don't like the idea at all, and I'm not willing to do it. Fair is fair.
Yes! Totally agree. Ansible's largest problem for me is trying to wrangle YAML into a domain it doesn't belong. This is why I prefer puppets approach, which is a domain specific language that maintains the idea of YAML in that its mostly declarative, desired state, but it still provides sane constructs for looping, conditionals and types. Ansible would benefit greatly from this.
The main problem I have with any kind of DSL (Python, Ruby, PHP, Go-based, whatever) is that it usually doesn't abstract enough of the underlying language away, meaning if you're not already a [language XYZ] developer or willing to learn some of the ins-and-outs of the underlying language, you're not going to be very productive.
With Ansible, you can go _very_ far before you have to know anything about Python (well, most of the time—annoyingly, there are situations like naming groups where Python's variable syntax leaks through currently).
It would be like making people know basic Go syntax just to write or edit a Kubernetes manifest—that immediately limits its appeal to those who have at least a passing interest in Go (which is a much smaller audience than 'willing to learn YAML, which is used all over the place').
I’ve worked with Puppet, Ansible, and Salt professionally in the past few years. Of the three, I’m unsure which I’d choose for greenfield, but I think I would rather inherit a legacy Salt codebase than one in Puppet or Ansible.
I've been working with puppet and ansible, and I'm sure I'd rather take on an ansible. I've been exposed to both and ansible has been far easier to figure out for me. Obviously this will be different for everyone depending on what you already know and who wrote that thing that you're inheriting.
Ansible seems to be better at declaring a particular configuration at build time, which should be repeatable and tested, and then perhaps running limited updates in a more controlled fashion later. The destination hosts should be disposable and recreated for any significant changes. If you write playbooks to change existing state frequently you have to be very careful to write in tasks that check the previous state. If you can version the roles and playbooks carefully then you can have some idea of the systems' state. For simple idempotency, like changing an app's config template and restarting a daemon, the modules have you covered, but for more complex dependencies between services it can get hairy. Some unpredictable things can happen. Example story: systemd-tmpfiles on CentOS 7 has a poorly documented behavior of skipping files in /tmp or /var/tmp that are both root-owned and read-only. It's not something in the options or config, just a default behavior (that was removed in later versions). We had a playbook that would clone a git repo into /var/tmp and then copy the required files into their appropriate place. The git module worked fine to update the repo each run, until several weeks passed and systemd-tmpfiles blew away most, but not all, of the repo files. Some files with just read permission remained. The module could handle either all the repo files existing or having the repo disappear just fine, but not a partially deleted repo. It would error out on that task. So now there's a new dependency on a changed systemd-tmpfiles config to skip that directory, and the partially deleted mess must be deleted for a run to work on existing hosts with the old config. There's lots of stuff like that that can accrue.
I've seen molecule mentioned a lot, but I've never used it. My understanding is that it will spin up a container, vm or cloud image for you, run your playbooks, validate the result and tear down for you. Seems like a lot of trouble. Red Hat maintains it, I believe.
I use a combination of Ansible and Docker. I use it for deploying to embedded platforms where sometimes you just want to reflash the board, or you have to upload a new kernel image for some reason. Or of course when a new board turns up! The goal is so that a new user can install everything from scratch with one command (which could be wrapped into a pretty GUI). I didn't want to go with storing a flash image because it's a lot of space and not portable. This setup will work on basically any dev board with minimal changes (the docker image is platform agnostic and can also be tested on amd64 as well as arm7 and aarch64). It took a while to set up, but I like using an approach which is very ephemeral - means you're forced to document exactly what you did to get the system to be in that state. And you don't worry that if you fry a board that it'll take days to set up again.
Ansible makes it easy to do mundane things like delete the default user and set up a new account, copy over ssh keys for easy access, add services and set up the docker container. Docker has the meaty stuff that takes ages to build and install, so I make sure it works and then save the image for easy download later.
What I've currently got going is everything in one repository, it has the playbooks, docker files, tests, service files, etc. I clone that using ansible on the target machine. Ansible then pulls the repo to get new changes and rebuilds the container. The container also adds that repo as a volume so that tests and other things are accessible. I don't store containers, I just spin up a new vm on boot.
I do have a "backup" playbook which installs everything inside the container when I want to test outside docker. This has happened a few times when using custom libraries that are specific to the embedded platform that don't come with the docker images (eg hardware accelerated gstreamer plugins come to mind). On the Pi life is a bit better because there are raspbian docker images anyway.
Most of the time I'm using Ansible to build containers or AMIs (or other images), which are then deployed, and overwritten for updates.
Other times, I write a secondary playbook to roll back some deployment if needed. (Though sometimes it's as simple as setting a `state=present` to `state=absent` for a few tasks and that's all that's required.
- if you change your email address, or have any problem with it (oups, google has blocked you again!), you can't log in. Have been bitten by this when myopera.com closed and I couldn't access my old email. I lost some accounts.
- emails are clear text, so bots can intercept a login link and use it
- if you want to share the account with somebody, you gotta give them access to your email
- I don't want my inbox to be polluted by 15 login email every day
- using my password manager is much faster than doing this
> We always include a backup code in the email you can manually paste in.
It's going to help me with any of that. Can't access backup code if email is closed. Won't prevent bot from stealing the account. Won't help me with sharing the account, I'm not going to give the backup code to the person every time they need to login.
> Do you need to login to things repeatedly? I mean, sure your bank... but what else do you log out of?
Banks. Stuff for which you have several accounts on the same service (I have 11 email accounts, 4 github accounts, 3 HN accounts, 3 reddit accounts). A lot of people have at least 2 fb accounts, one official and one personal, and most of them don't know about browser containers.
> You and I use a password manager... but are they mainstream? My parents sure dont
No, and I expect they will never be. Auth is not a solve problem.
But email links are not the solution. At best, one login option, and a good way to start off.
Password auth should always be offered. It's the most neutral, balanced, resilient, privacy friendly, interoperable stuff we have for now.
Python is jokingly said to be "the second best language for most things". To achieve this, it has to be able to be decent for many different purposes such as setuping machine learning models, scripting SIG system, doing test automation, powering a web site, provisioning linux servers, scrapping web page, batch renaming files and teaching code, analyzing numbers from a hdf5 file, being the client to a database/ftp/ssh/imap system.
It means it can't just be purely functional/OOP/imperative, be must borrow from each paradigm. Be statically typed or not, but gives features from both. Etc.
Because you don't want type hints when you are in jupyter or scripting your linux box. But you may want it when your Saas reach 3 millions lines.
> It's been explicitly stated that Python will never make the type hints mandatory
Type hints are already mandatory if you want to use data classes. This is unfortunate - the two features really should be orthogonal.
At least when Guido was still BDFL, there was little resistance to type hints encroaching on unrelated areas of the language, and hence becoming less-and-less optional.
One of the core requirements of the type hints design is that they don't affect the Python language.
You can still write python programs without them.
You can add them only partially.
You can also add them later.
Python stays Python.
MonkeyType lets you take a code base that is untyped, or partially typed, for historical or because it was not worth it at the time, and turn it into a fully typed project quickly.
It makes the transition between the exploration phase into the industrial phase much easier.
For me, it's kinda fantastic to be able to fiddle with a design, changing my mind again and again, without having to fight the type system, then once things are settled, add an additional safety net on top.
It's also very reassuring knowing I can just hack things, knowing that later on, if I want to take it to the next level, I have the option to change my mind about type hints.
Totally get that, and agree that this is an aspect if Python that is awesome for iteration on new ideas without many barriers.
However, this seems to make the assumptions that when you, as you say, transition to the industrial phase:
- MonkeyType will get all of the assumped types correct, which at any scale I doubt. Not because of the ability of the projects contributors, but because they warn about this in their own documentation
- If you're doing this at an industrial scale, and you haven't already documented/thought about/understood what these functions are. I'd appreciate that it may help intially, but still runs in to the problem I was discussing above.