kenoph

Impressive. Someone should do jq-jit too. I briefly looked into it and it seems like it would be _a lot_ of effort :/

Long time Android user, switched to iPhone when I broke the screen of my Google-gifted Nexus 3a. Final straw was the latest update. Every widget became bigger, with a border radius taking way too much space on the screen. Some widgets (e.g.: calendar) had part of the text hidden by the round edges. On top of that, I had a black-ish/brown-ish background and after the update all the UI was brown.

I honestly don't know what Google designers/engineers get paid to do if they can't even QA the software of one of their main devices.

I don't like Apple but I'm way happier now. Main complaint is the stupid photo/file separation. Just give me a normal filesystem please.

If capitalism causes censorship, that doesn't mean it's necessarily the worst at causing censorship.

Additionally, we don't live in a stationary society, so, whatever capitalism did or did not cause in the past might not apply as-is today.

Related: https://en.wikipedia.org/wiki/Inverted_totalitarianism

I did some research on PII being harvested by Android apps.

TL;DR: The EU could pay a couple of reverse engineers for 2 months and print money out of fines.

I was shocked to discover that (back then?) apps could just straight up read the list of user accounts on the phone without any special permission... Which is mostly fine, except many apps use your email/phone-number as account name or description. Same goes for Wi-Fi SSID and other things.

Tbh Unix programs don't handle non-ASCII text very well, in my experience.

You can do a lot with just bash + pipes + unix tools. It can get messy as your pipeline grows though, and there are a lot of edge cases.

Relevant: "bashML: Why Spark when you can Bash?" (https://rev.ng/blog/bashml/post.html), aka how to deduplicate git repositories using `comm` + `awk`.

I most certainly didn't imply that (:

But you did say it was illegal. Seems to me there are exceptions if that picture is to be trusted.e

Explain this to the folks at home: https://www.reddit.com/r/europe/comments/85qnx5/george_orwel...

Take notes on the main concepts / highlights, then make anki cards (: (I know it's easier said than done)

A lot of adblocking works at the DOM level.

Get ready for canvas-only websites with wasm. Good luck adblocking.

Just FYI: draw.io uses SVG foreignObjects for styling the text in the diagrams. That means that to get a proper rendering of the resulting SVG you need to look at it in a browser. If not, it has a fallback text element, but you lose the styling. I lost many hours due to this :/ other than that, I like it a lot

I see that kind of advice thrown around a lot, but that's just the sales pitch of PhDs, not the reality.

You might be interested in this: https://github.com/biemster/gasr (not production-grade, but depending on your workflow you can hack on it)

Guilty too. I had this idea to improve the order in which I should study kanjis. Ended up with a neo4j instance with kanjis, kanji components (not just radicals), words, and how they are combined.

Now I'm still using the same algorithm, but I do everything manually. It takes time but I found that the flashcard customization aspect makes the memorization easier.

My problem with Twitter is that a lot of researchers I follow make a lot of noise (e.g.: giving their opinions on things 10 times a day, tweeting random "facts" about life, etc...) but once in a while they tweet very informative stuff.

I feel kind of trapped following them :/

I tried using the "this tweet is not relevant" thingie but it doesn't do anything. I mean, this is a thing for which I would gladly have an AI-powered smart filter.

I think the question is not if you *can* work that many hours but if you *should* do it.

Ofc there will be a minority of people that perhaps even enjoy it, but the vast majority is gonna suffer serious mental health issues. Not to mention that, as others pointed out, some people like to have a life outside of work. If you work 60 hours a week you either don't sleep much or your life is just working and sleeping.

I am using descript for a project of mine. You can definitely still hear that they are AI-generated. But I'm sure it's not gonna take long. Couple this with SSML and it's going to be quite convincing.

They've been using wifi/cellphone data to track tourists' flow for at least a couple of years.

What seems new is the control tower thingie (Orwellian af) and the tracking of the tourists' origin.

I somehow doubt that they do all of that without ever storing sensitive data/personal identifiers. Anyhow, I suspect some italian journalist is gonna send some FOIAs soon (:

Actually I think the biggest problem is predicting correctly all the jump targets.

Yep. Actually we have a C helper per instruction and generate IR blocks full of CALLs to such helpers. Then the inliner and other optimizations take care of doing their work.

Anyway, if you never used LLVM, be ready to spend some time getting familiar with its IR and its C++ magic (though as a user I never had too much trouble... and I'm not a C++ guy). The documentation is also not very helpful, but the examples are good enough to get you started. The ORCv1 vs ORCv2 thing is kind of confusing sometimes.

Yep. For a project at my company we are doing pretty much the same as the author's (though for another architecture) and we JIT basic blocks on the fly using LLVM + C helpers.

Slightly OT, but even by JIT'ing + caching it's not always the case that your code run faster than a simple emulator. It sounds obvious written like this, but we were still surprised in some cases we encountered. But in our case it's probably related to the fact that the code we are jitting was not meant to be jitted, so we are doing some ugly things here and there. We also have to support self-modifying code (and that basically means blacklisting the jitter in some address ranges).

TL;DR: even with LLVM, emulation is often faster. QEMU tcg is likely faster than both, but it's GPL'd.

EDIT: wanted to add that LLVM JIT infrastructure is still moving quite a bit.

How about no? Parsers are one of the main sources of bugs in software. You should write parsers manually only when you have a very good reason to. Go ask any of your system security friends.

I kind of agree with Aaron Swartz: http://www.aaronsw.com/weblog/hatethenews

ctftime lists writeups, but in general you can google "whatever ctf challenge name writeup"

Static binary lifting is, in general, undecidable. Actually, correct disassembly is itself undecidable, and binary lifting builds on it. Doing it dynamically, like QEMU/tcg does, is doable.

It's really not too difficult to write a lifter, but it's time consuming. You have to take every instruction from the source instruction set and model its side effects in some IR. To make things simple, "whole binary" lifting tools seem to use a global CPU state (registers, flags, etc...) and so the IR you get is quite different from what you would obtain from a compiled program.

I did my Master Thesis on this kind of stuff. There are many Apps among the top 100 free ones that ask permissions completely unrelated to their functionality. Yeah I know, not surprising. What surprised me at the time was that Android gives away much information "for free". For example, if I recall correctly, GET_ACCOUNTS was granted automatically and it allowed to get the "title" of every account on the phone as shown in the Android UI. Most Apps use the actual username as the title, google included (aka, every App could read your email address). Nice exceptions are Signal and WhatsApp.

Last time I tried it, it didn't handle unicode very well. It was a year ago and, when I saved the documents, things like "à" would turn to Chinese characters. Apart from this, I liked it a lot. Now I just use VIM and pandoc for PDFs.

I get your point, but say you were selling food instead of services. It's on you to make sure that what you are importing doesn't break any rule (GMO, other stuff, etc...).

I think it's fair. You shouldn't break the law. That regulation may be overkill in terms of punishment, but that doesn't mean that the regulation itself is wrong. Laws are imperfect. Regulations exist in every industry and there's a reason for that. Over regulating is a burden for a business, but under regulating is bad for customers (or the environment, or whatever).