These are good designs that have been entirely ignored by developers in every commanding scale codebase I've ever worked on. "That's the developers fault, not the languages" Look, the old grey mares of the programming world are doing the worst they can. I'm not going to blame C because its developers generally make it up as they go. But we've learned things over the past 50 years, and one of the things we've learned is that company defined 'worst practices' and code reviews can not catch all the mistakes that developers make and all of the things that can bring a service to its knees. Go has the impact of experience. It knows what mistakes developers make and it is going to prevent them from doing that. There is Right Way To Handle Errors in Go. How hundreds times have I seen uncaught exceptions? I saw one a week ago. How concentration times have I lost resources because I didn't realize something I was calling could throw exceptions? hundreds. Null/Nil exceptions. I couldn't count the null pointer errors I've had to fix in my time. supposedly in the remainder. "should" keep things wide and shallow - somehow when scala 8 came out all the docker programmers lost this message. None of these practices scale. We know that because we've seen it
No, because the notification timing is not reliable. It can vary a lot depending on the load on that microservice at any given time. Also, how would you handle dits, dahs, and gaps?
You only have 1 variable in your control, the time in-between follows. (I say this because there is no notification for "unfollowing" someone)
You need to represent 2 variables : the dot/dash to represent symbols, and the dit, the time in-between symbols.
If you want to do this you need some sort of 2nd action, a comment or a twitter like, that way we could represent the dot/dash with either action, and then space them out to time the silence.
Or you can use "Morse tap code" where two close knocks represent a dot, and if the gap between them is slightly longer it's a dash. That takes two knocks for one dot/dash but it works and is (was?) used in practice.
More seriously, the events end up in a list, so a recipient would more likely "decode" them by comparing timestamps instead of "live" watching the actual sequence.
But I suppose if you timed your follows/unfollows really carefully, you could get certain patterns in the timestamps to appear which could be used to distinguish "long" and "short" pulses.
No, actually, I was just wondering if messaging like that is even possible; I suppose I’ve been reading a lot lately about encryption and private messaging in public spaces.
Thinking out loud: using follow/unfollow you transmit a signal with no information. using the timing between the signal you are encoding symbols. I think this is called Pulse Position Modulation[0]
First step is to characterize the delta in the timestamps. That will give you an idea of what time-between-follows (TBF) should be to ensure reliable detection.
You could probably make a client for this. Build comms on top of twitter protocol.
Haven't used twitter in over 10 years, but this kinda makes me want to again.
Side note: reminds me of why gmail scans drafts. Criminals used a signal account and create drafts to communicate back and forth. This prevented detection because intel agencies scan email traffic, not drafts.
EDIT: why stop with twitter. what makes this powerful is that it leverages a feature every platform has. Youtube, Twitch, you name it. Let's go my dude.
Let's say you could follow and unfollow once a second and they knew it. Then you could replicate the dots and dashes by the length of time you toggled the status plus the gaps where you weren't toggling at all.
Eg in the first ten seconds 10 toggles, in the next 10 seconds a 5 second gap then 5 toggles. That would be dash, quiet, dot.
With just follow/unfollowing, you can't truly encode Morse code. You would have to override a metadata field or agree on an external clock source to overcome the idempotent follow/unfollow action and encode language into the state machine.
These are good designs that have been entirely ignored by developers in every commanding scale codebase I've ever worked on. "That's the developers fault, not the languages" Look, the old grey mares of the programming world are doing the worst they can. I'm not going to blame C because its developers generally make it up as they go. But we've learned things over the past 50 years, and one of the things we've learned is that company defined 'worst practices' and code reviews can not catch all the mistakes that developers make and all of the things that can bring a service to its knees. Go has the impact of experience. It knows what mistakes developers make and it is going to prevent them from doing that. There is Right Way To Handle Errors in Go. How hundreds times have I seen uncaught exceptions? I saw one a week ago. How concentration times have I lost resources because I didn't realize something I was calling could throw exceptions? hundreds. Null/Nil exceptions. I couldn't count the null pointer errors I've had to fix in my time. supposedly in the remainder. "should" keep things wide and shallow - somehow when scala 8 came out all the docker programmers lost this message. None of these practices scale. We know that because we've seen it
No, because the notification timing is not reliable. It can vary a lot depending on the load on that microservice at any given time. Also, how would you handle dits, dahs, and gaps?
Your questions are quite sensible; I suppose I need to think about an asynchronous Morse code algorithm as well :)
You only have 1 variable in your control, the time in-between follows. (I say this because there is no notification for "unfollowing" someone)
You need to represent 2 variables : the dot/dash to represent symbols, and the dit, the time in-between symbols.
If you want to do this you need some sort of 2nd action, a comment or a twitter like, that way we could represent the dot/dash with either action, and then space them out to time the silence.
Well, you can use tap code: https://en.wikipedia.org/wiki/Tap_code
Or you can use "Morse tap code" where two close knocks represent a dot, and if the gap between them is slightly longer it's a dash. That takes two knocks for one dot/dash but it works and is (was?) used in practice.
Yes JofArnolds response is similar where you just switch a flag on/off to draw dots and dashes and dits
It seems it can be done using a few different components, even if not directly by “following”, thank you
Were you blocked?
More seriously, the events end up in a list, so a recipient would more likely "decode" them by comparing timestamps instead of "live" watching the actual sequence.
But I suppose if you timed your follows/unfollows really carefully, you could get certain patterns in the timestamps to appear which could be used to distinguish "long" and "short" pulses.
No, actually, I was just wondering if messaging like that is even possible; I suppose I’ve been reading a lot lately about encryption and private messaging in public spaces.
Yeah, was more a joke too :) But the idea is interesting. I think in general there is a lot of metadata that could be used as covert channels.
Thinking out loud: using follow/unfollow you transmit a signal with no information. using the timing between the signal you are encoding symbols. I think this is called Pulse Position Modulation[0]
First step is to characterize the delta in the timestamps. That will give you an idea of what time-between-follows (TBF) should be to ensure reliable detection.
You could probably make a client for this. Build comms on top of twitter protocol.
Haven't used twitter in over 10 years, but this kinda makes me want to again.
Side note: reminds me of why gmail scans drafts. Criminals used a signal account and create drafts to communicate back and forth. This prevented detection because intel agencies scan email traffic, not drafts.
EDIT: why stop with twitter. what makes this powerful is that it leverages a feature every platform has. Youtube, Twitch, you name it. Let's go my dude.
[0] https://en.wikipedia.org/wiki/Pulse-position_modulation
Let's say you could follow and unfollow once a second and they knew it. Then you could replicate the dots and dashes by the length of time you toggled the status plus the gaps where you weren't toggling at all.
Eg in the first ten seconds 10 toggles, in the next 10 seconds a 5 second gap then 5 toggles. That would be dash, quiet, dot.
Although not directly by “following”, as king_zee said, it seems it can be done using a few different components; thank you
I had the same thought.
.. ..-. / -.-- --- ..- / -.-. .- -. / .-. . .- -.. / - .... .. ... --..-- / - --- ..- -.-. .... / --. .-. .- ... ...
Finally, someone who understands me :)
With just follow/unfollowing, you can't truly encode Morse code. You would have to override a metadata field or agree on an external clock source to overcome the idempotent follow/unfollow action and encode language into the state machine.
I suppose the interval between the two actions would correspond to a letter in the Morse code here
That would require an additional lookup table that doesn't qualify as Morse code, as well as an external clock source.
I suppose I should have gone over how Morse code works again before asking this question. Thank you.
Do you mean following and unfollowing in some sort of rapid succession?
Yes, I think that’s exactly what I’m talking about; the interval between the two actions would correspond to a letter in Morse code