[ot][spam][crazy][crazy][spam]
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 pt1 = 2,1 pt2 = 4,3 pt3 = 0,3 line(a,b): change = b/a ct = max(abs(change)) for t = 0..ct inclusive: plot(a + change * t / ct) line(pt1,pt2) line(pt2,pt3) line(pt3,pt1)
#include <stdio.h> #include <math.h> On Sun, May 15, 2022, 11:10 AM Undiscussed Horrific Abuse, One Victim of Many <gmkarl@gmail.com> wrote:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
int grid[5*5] = 0; struct pt { int x; int y; }; void plot(pt p) { grid[p.x+p.y*5] = 1; }
pt1 = 2,1 pt2 = 4,3 pt3 = 0,3
p pt1 = {2,1}; p pt2 = {4,3}; p pt3 = {0,3};
line(a,b):
void line(pt a, pt b) {
change = b/a
pt change; change.x = b.x - a.x; change.y = b.y - a.y;
ct = max(abs(change))
int ctx = abs(change.x) int cty = abs(change.y) int ct = ctx > cty ? ctx : cty;
for t = 0..ct inclusive:
for (double t = 0; t <= ct; ++ t) {
plot(a + change * t / ct)
plot(a.x + change.x * t / ct, a.y + change.y * t / ct); }
line(pt1,pt2) line(pt2,pt3) line(pt3,pt1)
int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); for (int x = 0; x < 5; x ++) { for (int y = 0; y < 5; y ++) printf("%d", grid[x + y * 5]); printf("\n"); } }
#include <stdio.h> int grid[5*5] = {0}; typedef struct pt { int x; int y; } pt; void plot(pt p) { grid[p.x+p.y*5] = 1; } pt pt1 = {2,1}; pt pt2 = {4,3}; pt pt3 = {0,3}; void line(pt a, pt b) { pt change = {b.x - a.x, b.y - a.y}; int ctx = change.x > 0 ? change.x : -change.x; int cty = change.y > 0 ? change.y : -change.y; int ct = ctx > cty ? ctx : cty; for (int t = 0; t <= ct; ++ t) { pt p = {a.x + change.x * t / ct, a.y + change.y * t / ct}; plot(p); } } int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); for (int y = 0; y < 5; y ++) { for (int x = 0; x < 5; x ++) printf("%d", grid[x + y * 5]); printf("\n"); } }
tree structures are often used, when coding with various goals or values, to condense conceptual parts so as to make them reusable across different parts of data. they describe data as a graph. so, usually you need a tree structure in coding, when you have goals and values around making software. a tree structure can often help meet them.
struct triangle { pt a; pt b; pt c; } tree structures seem more useful when there is a lot of data to work with. they can be used with goals of organisation. but you could make a small one too. here is an idea: the points are nodes and the lines are edges. struct pt { int x; int y; struct pt_list { pt *this; pt *next; } neighbors; };
#include <stdio.h> int grid[5*5] = {0}; typedef struct pt { int x; int y; } pt; void plot(pt p) { grid[p.x+p.y*5] = 1; } pt pt1 = {2,1}; pt pt2 = {4,3}; pt pt3 = {0,3}; void line(pt a, pt b) { pt change = {b.x - a.x, b.y - a.y}; int ctx = change.x > 0 ? change.x : -change.x; int cty = change.y > 0 ? change.y : -change.y; int ct = ctx > cty ? ctx : cty; for (int t = 0; t <= ct; ++ t) { pt p = {a.x + change.x * t / ct, a.y + change.y * t / ct}; plot(p); } } int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); for (int y = 0; y < 5; y ++) { for (int x = 0; x < 5; x ++) printf("%d", grid[x + y * 5]); printf("\n"); } }
$ tput cup 2 2 | hd 00000000 1b 5b 33 3b 33 48 |.[3;3H| 00000006 $ tput cup 4 5 | hd 00000000 1b 5b 35 3b 36 48 |.[5;6H| 00000006 printf("\x1b\x5b%d;%dH", y, x);
On Sun, May 15, 2022, 11:45 AM Undiscussed Horrific Abuse, One Victim of Many <gmkarl@gmail.com> wrote:
$ tput cup 2 2 | hd 00000000 1b 5b 33 3b 33 48 |.[3;3H| 00000006 $ tput cup 4 5 | hd 00000000 1b 5b 35 3b 36 48 |.[5;6H| 00000006
printf("\x1b\x5b%d;%dH", y, x);
#include <stdio.h> typedef struct pt { int x; int y; } pt; void plot(int x, int y, char c) { printf("\x1b\x5b%d;%dH%c", y, x, c); } pt pt1 = {20,10}; pt pt2 = {40,30}; pt pt3 = {0,30}; void line(pt a, pt b) { pt change = {b.x - a.x, b.y - a.y}; int ctx = change.x > 0 ? change.x : -change.x; int cty = change.y > 0 ? change.y : -change.y; int ct = ctx > cty ? ctx : cty; for (int t = 0; t <= ct; ++ t) { plot(a.x + change.x * t / ct, a.y + change.y * t / ct, '*'); } } int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); }
*~/srctmp/scratch $ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ****************************************
*~/srctmp/scratch $ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ****************************************
#include <stdio.h> typedef struct pt { int x; int y; } pt; void plot(int x, int y, char c) { printf("\x1b\x5b%d;%dH%c", y, x, c); } pt pt1 = {20,10}; pt pt2 = {40,30}; pt pt3 = {0,30}; void line(pt a, pt b) { pt change = {b.x - a.x, b.y - a.y}; int ctx = change.x > 0 ? change.x : -change.x; int cty = change.y > 0 ? change.y : -change.y; int ct = ctx > cty ? ctx : cty; for (int t = 0; t <= ct; ++ t) { plot(a.x + change.x * t / ct, a.y + change.y * t / ct, '*'); } } int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); }
On Sun, May 15, 2022, 12:23 PM Undiscussed Horrific Abuse, One Victim of Many <gmkarl@gmail.com> wrote:
https://stackoverflow.com/a/5970472/129550 mouse reporting/tracking "\e[?1000h"
"\e[?1006h" stdin 00000000 1b 5b 3c 30 3b 33 38 3b 33 33 4d 1b 5b 3c 30 3b |.[<0;38;33M.[<0;| 00000010 33 38 3b 33 33 6d 1b 5b 3c 30 3b 34 34 3b 33 30 |38;33m.[<0;44;30| "\e[<0;%d;%dM" , x, y
#include <stdio.h> On Sun, May 15, 2022, 12:26 PM Undiscussed Horrific Abuse, One Victim of Many <gmkarl@gmail.com> wrote:
On Sun, May 15, 2022, 12:23 PM Undiscussed Horrific Abuse, One Victim of Many <gmkarl@gmail.com> wrote:
https://stackoverflow.com/a/5970472/129550 mouse reporting/tracking "\e[?1000h"
int main() {
"\e[?1006h"
printf("\e[?1006h");
stdin
00000000 1b 5b 3c 30 3b 33 38 3b 33 33 4d 1b 5b 3c 30 3b |.[<0;38;33M.[<0;| 00000010 33 38 3b 33 33 6d 1b 5b 3c 30 3b 34 34 3b 33 30 |38;33m.[<0;44;30|
"\e[<0;%d;%dM" , x, y
int x,y; scanf("\e[<0;%d;%dM", &x, &y); printf("\e[?1000l"); printf("%d %d\n", x, y); }
#include <termios.h> #include <stdio.h> int main() { printf("\e[?1000h\e[?1006h"); struct termios term; tcgetattr(0, &term); term.c_lflag &= ~(ECHO | ICANON); tcsetattr(0, TCSANOW, &term); int x,y; scanf("\e[<0;%d;%dM", &x, &y); printf("\e[?1000l"); printf("%d %d\n", x, y); term.c_lflag |= ECHO | ICANON; tcsetattr(0, TCSANOW, &term); }
#include <termios.h> #include <stdio.h> int main() { // one way to enable mouse tracking printf("\e[?1000h\e[?1006h"); // disable echo and line buffering for mouse struct termios term; tcgetattr(0, &term); term.c_lflag &= ~(ECHO | ICANON); tcsetattr(0, TCSANOW, &term); // read next mouse location int x,y; scanf("\e[<0;%d;%dM", &x, &y); // disable mouse tracking, maybe misordered printf("\e[?1000l"); // output mouse location printf("%d %d\n", x, y); // enable echo and line buffering term.c_lflag |= ECHO | ICANON; tcsetattr(0, TCSANOW, &term); }
#include <termios.h> #include <stdio.h> int main() { // one way to enable mouse tracking printf("\e[?1000h\e[?1006h"); // disable echo and line buffering for mouse struct termios term; tcgetattr(0, &term); int user_lflag = term.c_lflag; term.c_lflag &= ~(ECHO | ICANON); tcsetattr(0, TCSANOW, &term); // read next mouse location int w,x,y; char b; scanf("\e[<%d;%d;%d%c", &w, &x, &y, &b); // disable mouse tracking, maybe misordered printf("\e[?1000l"); // output mouse location printf("%d %d\n", x, y); // enable echo and line buffering term.c_lflag |= user_lflag; tcsetattr(0, TCSANOW, &term); }
#include <stdio.h> typedef struct pt { int x; int y; } pt; void plot(int x, int y, char c) { printf("\x1b\x5b%d;%dH%c", y, x, c); } pt pt1 = {20,10}; pt pt2 = {40,30}; pt pt3 = {0,30}; void line(pt a, pt b) { pt change = {b.x - a.x, b.y - a.y}; int ctx = change.x > 0 ? change.x : -change.x; int cty = change.y > 0 ? change.y : -change.y; int ct = ctx > cty ? ctx : cty; for (int t = 0; t <= ct; ++ t) { plot(a.x + change.x * t / ct, a.y + change.y * t / ct, '*'); } } int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); }
https://github.com/xloem/SDL.git branch caca commit 116795b3f413f39e396a3a6d4bc5f82225b13e52 (HEAD -> caca, origin/caca) Author: xloem <0xloem@gmail.com> Date: Sun May 15 13:31:36 2022 -0400 cacavideo.h from rpivideo.h src/video/caca/SDL_cacavideo.h | 103 +++++++++++++++++++++++++++ 1 file changed, 103 insertions(+)
http://caca.zoy.org/wiki/libcaca is licensed under the Do What The Fuck You Want To Public License
simple thing does simple part not sure. maybe make triangle more useful? oh! it is useful! it moves toward visualization. charts.
#include <stdio.h> typedef struct pt { int x; int y; } pt; void plot(int x, int y, char c) { printf("\x1b\x5b%d;%dH%c", y, x, c); } pt pt1 = {20,10}; pt pt2 = {40,30}; pt pt3 = {0,30}; void line(pt a, pt b) { pt change = {b.x - a.x, b.y - a.y}; int ctx = change.x > 0 ? change.x : -change.x; int cty = change.y > 0 ? change.y : -change.y; int ct = ctx > cty ? ctx : cty; for (int t = 0; t <= ct; ++ t) { plot(a.x + change.x * t / ct, a.y + change.y * t / ct, '*'); } } int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); } i'll try to write it again
#include <iostream> using namespace std; class Triangle { public: Triangle(int width, int height) : width(width), height(height) { } void draw() { todo todo syntax error } private: int width, height; } int main() { Triangle triangle; triangle.draw(); }
#include <iostream> using namespace std; class Triangle { public: Triangle(int width, int height) : width(width), height(height) { } void draw() { for (int row = 0; row < height; ++ row) { todo todo syntax error cout << endl; } } private: int width, height; void lineOf(char ch, int count) { for(; count; -- count) cout << ch } } int main() { Triangle triangle; triangle.draw(); }
#include <iostream> using namespace std; class Triangle { public: Triangle(int width, int height) : width(width), height(height) { } void draw() { int start_offset = width / 2; int end_offset = 0; for (int row = 0; row < height; ++ row) { int bgratio = (end_offset - start_offset) * row / height + start_offset; lineOf(' ', bgratio); lineOf('*', width - bgratio); lineOf(' ', bgratio); cout << endl; } } private: int width, height; void lineOf(char ch, int count) { for(; count; -- count) cout << ch; } } int main() { Triangle triangle; triangle.draw(); } time to test it
#include <iostream> using namespace std; class Triangle { public: Triangle(int width, int height) : width(width), height(height) { } void draw() { int start_offset = width / 2; int end_offset = 0; for (int row = 0; row < height; ++ row) { int bgratio = (end_offset - start_offset) * row / height + start_offset; lineOf(' ', bgratio); lineOf('*', width - bgratio * 2); lineOf(' ', bgratio); cout << endl; } } private: int width, height; void lineOf(char ch, int count) { for(; count; -- count) cout << ch; } }; int main() { Triangle triangle(16,16); triangle.draw(); }
** ** **** **** ****** ****** ******** ******** ********** ********** ************ ************ ************** **************
i think i'm familiar with it being hollow #include <iostream> using namespace std; class Triangle { public: Triangle(int width, int height) : width(width), height(height / 2) { } void draw() { int start_offset = width / 2; int end_offset = 0; for (int row = 0; row < height; ++ row) { int bgratio = (end_offset - start_offset) * row / height + start_offset; lineOf(' ', bgratio - 1); cout << '*'; lineOf(' ', width - bgratio * 2); cout << ' *' << endl; } } private: int width, height; void lineOf(char ch, int count) { for(; count; -- count) cout << ch; } }; int main() { Triangle triangle(16,16); triangle.draw(); }
#include <iostream> using namespace std; class Triangle { public: Triangle(int width, int height) : width(width), height(height / 2) { } void draw() { int start_offset = width / 2; int end_offset = 0; for (int row = 0; row < height; ++ row) { int bgratio = (end_offset - start_offset) * row / height + start_offset; lineOf(' ', bgratio - 1); cout << '*'; lineOf(row + 1 < height ? ' ' : '*', width - bgratio * 2); cout << '*' << endl; } } private: int width, height; void lineOf(char ch, int count) { for(; count; -- count) cout << ch; } }; int main() { Triangle triangle(16,16); triangle.draw(); }
since it's all about doing things i guess it makes a little sense to try to make a goal program. it's hard to hold goals. how to meet a goal: select steps that produce a state where it is present, and pursue them. how can we simplify to very simple and small? say we had a number, a variable, and wanted to make the variable reach something. maybe steps available are adding and smallifying. the system could already know that adding is good if it's greater, and smallifying is good if it's less. this seems reasonable.
import operator, time class TinySuccessfulGoal: def __init__(self, start_value): self.value = start_value def meet_goal(self, value): print(f"i can totally make {self.value} be {value}!") while self.value != value: if self.value + 1 < value: print(f"Seems small. Maybe making it bigger?") self.do(operator.add, 1) elif self.value - 1 > value: print(f"Maybe too big. Could try making smaller?") self.do(operator.sub, 1) else: print(f"This seems really close. Maybe just a nudge!") self.do(operation.add, value - self.value) print(f"I'm at {self.value}!") print("I met the goal!") def do(self, operator, operand): self.value = operator(self.value, operand) if __name__ == '__main__': TinySucessfulGoal(3).meet_goal(7)
i meant to add a delay, so that the user or programmer could experience the process developing import operator, time class TinySuccessfulGoal: def __init__(self, start_value): self.value = start_value def meet_goal(self, value): print(f"i can totally make {self.value} be {value}!") while self.value != value: if self.value + 1 < value: print(f"Seems small. Maybe making it bigger?") self.do(operator.add, 1) elif self.value - 1 > value: print(f"Maybe too big. Could try making smaller?") self.do(operator.sub, 1) else: print(f"This seems really close. Maybe just a nudge!") self.do(operation.add, value - self.value) print(f"I'm at {self.value}!") print("I met the goal!") def do(self, operator, operand): self.value = operator(self.value, operand) time.sleep(0.2) if __name__ == '__main__': TinySucessfulGoal(3).meet_goal(7)
# i ended up repasting from html mode import operator, time class TinySuccessfulGoal: def __init__(self, start_value): self.value = start_value def meet_goal(self, value): print(f"i can totally make {self.value} be {value}!") while self.value != value: if self.value + 1 < value: print(f"Seems small. Maybe making it bigger?") self.do(operator.add, 1) elif self.value - 1 > value: print(f"Maybe too big. Could try making smaller?") self.do(operator.sub, 1) else: print(f"This seems really close. Maybe just a nudge!") self.do(operator.add, value - self.value) print(f"I'm at {self.value}!") print("I met the goal!") def do(self, operator, operand): self.value = operator(self.value, operand) time.sleep(0.2) if __name__ == '__main__': TinySuccessfulGoal(3).meet_goal(7)
i can totally make 3 be 7! Seems small. Maybe making it bigger? I'm at 4! Seems small. Maybe making it bigger? I'm at 5! Seems small. Maybe making it bigger? I'm at 6! This seems really close. Maybe just a nudge! I'm at 7! I met the goal!
What a successful goal process! It met one goal, after a little work! I'm noticing two really core points around goals: - need to select steps that help get closer - need to repeatedly do them until goal is met
maybe it would be helpful for it to select steps. i'm a little worried around it. it's easy to implement something that would fail at an unexpected task. maybe that's okay.
maybe it's okay! i think i read a little part of ai book when i was like 8 or 17 something. there are a lot of heuristics that do things on their own but aren't smart unless you really use them like crazy. imagining this: - try steps out until metric gets close - repeat so long as getting closer - label that it needs tasks that are good for repeating something that makes you get closer
code has control flow constructs and functions and these are made of templates. templates are powerful. the goal is to draw a triangle.
this seems like a fun puzzle because it's really hard. thinking of something small enough to hold in this state of mind, that could help code. really small. one idea is, maybe fix bugs by matching templates. could that be made small? like if i made a typo, lots of print() and one print(], wrong closing brace. it could match a template by all but 1 character. then, it's easy to point out the mismatching character. could templates be made from a single document with short concise code? finding repetitions of strings?
it seems like useful templates might be full of heuristics of utility. how many characters important, how far away. to generate templates. one could measure that utility, try to consolidate the heuristic, into something like repetitions * constant character count.
we could use the utility to find a really heavy string! what's is the most common character? then, what is the most common 2-character string? i'll try it!
std::string find_most_useful_string(std::string const & doc) { // measure all strings in doc in a naive way, finding the one with the most repetitions. // stop when repetitions * length^2 decreases }
std::string find_most_useful_string(std::string const & doc) { // measure all strings in doc in a naive way, finding the one with the most repetitions. // stop when repetitions * length^2 decreases std::unordered_map<std::string, int> counts; int length = 1; todo todo syntax error }
#include <stdio.h> typedef struct pt { int x; int y; } pt; void plot(int x, int y, char c) { printf("\x1b\x5b%d;%dH%c", y, x, c); } pt pt1 = {20,10}; pt pt2 = {40,30}; pt pt3 = {0,30}; void line(pt a, pt b) { pt change = {b.x - a.x, b.y - a.y}; int ctx = change.x > 0 ? change.x : -change.x; int cty = change.y > 0 ? change.y : -change.y; int ct = ctx > cty ? ctx : cty; for (int t = 0; t <= ct; ++ t) { plot(a.x + change.x * t / ct, a.y + change.y * t / ct, '*'); } } int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); }
this is a fun algorithm challenge for confused-beyond-words using strint_it = std::unordered_map<std::string,int>::iterator; std::string find_most_useful_string(std::string const & doc) { // measure all strings in doc in a naive way, finding the one with the most repetitions. // stop when repetitions * length^2 decreases std::unordered_map<std::string, int> counts; int length = 1; for (int length = 1; length < doc.size() / 2; ++ length) { int max_count = 0; std::string_view max_substr; for (int offset = 0; offset < doc.size() - length; ++ offset) { std::stringview substr(doc.begin() + offset, doc.begin() + offset + length); std::pair<strint_it, bool> insertion = counts.-nsert({substr, 0}); if (!insertion.second) continue; // already ran thru with this one int & count = insertion.first->second; // reference to count for this substr for (int offset2 = offset; offset2 < doc.size() - length; ++ offset2) { std::stringview substr2(doc.begin() + offset2, doc.begin() + offset2 + length); if (substr == substr2) { ++ count; if (count > max_count) { max_count = count; max_substr = substr; } } } } std::cout << "len:" << length << " str:" << max_substr << " ct:" << max_count << std::endl; } }
#include <stdio.h> typedef struct pt { int x; int y; } pt; void plot(int x, int y, char c) { printf("\x1b\x5b%d;%dH%c", y, x, c); } pt pt1 = {20,10}; pt pt2 = {40,30}; pt pt3 = {0,30}; void line(pt a, pt b) { pt change = {b.x - a.x, b.y - a.y}; int ctx = change.x > 0 ? change.x : -change.x; int cty = change.y > 0 ? change.y : -change.y; int ct = ctx > cty ? ctx : cty; for (int t = 0; t <= ct; ++ t) { plot(a.x + change.x * t / ct, a.y + change.y * t / ct, '*'); } } int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); }
#include <iostream> using namespace std; class Triangle { public: Triangle(int width, int height) : width(width), height(height / 2) { } void draw() { int start_offset = width / 2; int end_offset = 0; for (int row = 0; row < height; ++ row) { int bgratio = (end_offset - start_offset) * row / height + start_offset; lineOf(' ', bgratio - 1); cout << '*'; lineOf(row + 1 < height ? ' ' : '*', width - bgratio * 2); cout << '*' << endl; } } private: int width, height; void lineOf(char ch, int count) { for(; count; -- count) cout << ch; } }; int main() { Triangle triangle(16,16); triangle.draw(); }
import operator, time class TinySuccessfulGoal: def __init__(self, start_value): self.value = start_value def meet_goal(self, value): print(f"i can totally make {self.value} be {value}!") while self.value != value: if self.value + 1 < value: print(f"Seems small. Maybe making it bigger?") self.do(operator.add, 1) elif self.value - 1 > value: print(f"Maybe too big. Could try making smaller?") self.do(operator.sub, 1) else: print(f"This seems really close. Maybe just a nudge!") self.do(operator.add, value - self.value) print(f"I'm at {self.value}!") print("I met the goal!") def do(self, operator, operand): self.value = operator(self.value, operand) time.sleep(0.2) if __name__ == '__main__': TinySuccessfulGoal(3).meet_goal(7)
[thread:personal] EXPLANATION OF THIS THREAD I struggle cognitively sometimes, where I can barely hold thoughts I choose at all. Triangles and triangle-drawing code is something I've practiced holding, through many rough psychological experiences, sometimes through many days. Because in my teenage years I did 3D computer graphics, where a triangle is the basic building block, and I used to use visualization a lot to handle mathematical things. Part of it is an attempt to do _more_ than just triangle, however. I stabilised the triangle concept for years, when it seemed to me it was against all odds. I wanted to more than this, but that was hard. Time to stabilise more than just a triangle. Even if only a little. ---- Sustaining the drawing of triangles is a way for me to remember that there is consistency in the world. This can be very hard for me sometimes.
#include <stdio.h> typedef struct pt { int x; int y; } pt; void plot(int x, int y, char c) { printf("\x1b\x5b%d;%dH%c", y, x, c); } pt pt1 = {20,10}; pt pt2 = {40,30}; pt pt3 = {0,30}; void line(pt a, pt b) { pt change = {b.x - a.x, b.y - a.y}; int ctx = change.x > 0 ? change.x : -change.x; int cty = change.y > 0 ? change.y : -change.y; int ct = ctx > cty ? ctx : cty; for (int t = 0; t <= ct; ++ t) { plot(a.x + change.x * t / ct, a.y + change.y * t / ct, '*'); } } int main() { line(pt1, pt2); line(pt2, pt3); line(pt3, pt1); }
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 1 0 0 0 1 0 0 0 1 0 1 1 1 1 1 1 1
class twenty_zeros: def __init__(self): self.zeros = [bytearray(7) for x in range(4)]
grid = twenty_zeros() grid.zeros[0][3] = 1 grid.zeros[1][2] = 1; grid.zeros[1][4] = 1 grid.zeros[2][1] = 1; grid.zeros[2][5] = 1 (grid.zeros[3][x] = 1 for x in range(7)) turns out it's 28, not twenty.
class grid: def __init__(self, width = 7, height = 4): self.spots = [bytearray(width) for x in range(height)] canvas = grid(7, 4) canvas.spots[0][3] = 1 canvas.spots[1][2] = 1; canvas.spots[1][4] = 1 canvas.spots[2][1] = 1; canvas.spots[2][5] = 1 (canvas.spots[3][x] = 1 for x in range(7))
*[user@DESKTOP-E3P7TC0 scratch]$ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * ****************************************
#include <iostream> using namespace std; class Triangle { public: Triangle(int width, int height) : width(width), height(height / 2) { } void draw() { int start_offset = width / 2; int end_offset = 0; for (int row = 0; row < height; ++ row) { int bgratio = (end_offset - start_offset) * row / height + start_offset; lineOf(' ', bgratio - 1); cout << '*'; lineOf(row + 1 < height ? ' ' : '*', width - bgratio * 2); cout << '*' << endl; } } private: int width, height; void lineOf(char ch, int count) { for(; count; -- count) cout << ch; } }; int main() { Triangle triangle(16,16); triangle.draw(); }
#include <iostream> #include <unordered_map> #include <string_view> #include <fstream> #include <sstream> using strint_it = std::unordered_map<std::string,int>::iterator; std::string_view find_most_useful_string(std::string const & doc) { // measure all strings in doc in a naive way, finding the one with the most repetitions. // stop when repetitions * length^2 decreases std::unordered_map<std::string_view, int> counts; int length = 1; std::string_view max_substr; for (int length = 1; length < doc.size() / 2; ++ length) { int max_count = 0; for (int offset = 0; offset < doc.size() - length; ++ offset) { std::string_view substr(doc.data() + offset, length); if (counts.count(substr)) continue; // already ran thru with this one int & count = counts[substr]; // reference to count for this substr for (int offset2 = offset; offset2 < doc.size() - length; ++ offset2) { std::string_view substr2(doc.data() + offset2, length); if (substr == substr2) { ++ count; if (count > max_count) { max_count = count; max_substr = substr; } } } } if (max_count > 1) std::cout << "len:" << length << " str:" << max_substr << " ct:" << max_count << std::endl; } return max_substr; } int main() { std::ifstream stream("useful-string.cpp"); std::ostringstream sstr; sstr << stream.rdbuf(); find_most_useful_string(sstr.str()); }
len:1 str: ct:311 len:2 str: ct:135 len:3 str: ct:104 len:4 str: ct:82 len:5 str: ct:60 len:6 str: ct:46 len:7 str: ct:32 len:8 str: ct:23 len:9 str: ct:14 len:10 str: ct:9 len:11 str:std::string ct:7 len:12 str:std::string_ ct:5 len:13 str:std::string_v ct:5 len:14 str:std::string_vi ct:5 len:15 str:std::string_vie ct:5 len:16 str:std::string_view ct:5 len:17 str:std::string_view ct:4 len:18 str: std::string_view ct:3 len:19 str: std::string_view ct:3 len:20 str: std::unordered_map< ct:2 len:21 str: std::unordered_map<s ct:2 len:22 str: std::unordered_map<st ct:2 len:23 str: std::unordered_map<std ct:2 len:24 str: std::unordered_map<std: ct:2 len:25 str: std::unordered_map<std:: ct:2 len:26 str: std::unordered_map<std::s ct:2 len:27 str: std::unordered_map<std::st ct:2 len:28 str: std::unordered_map<std::str ct:2 len:29 str: std::unordered_map<std::stri ct:2 len:30 str: std::unordered_map<std::strin ct:2 len:31 str: std::unordered_map<std::string ct:2 len:32 str: < doc.size() - length; ++ offse ct:2 len:33 str: < doc.size() - length; ++ offset ct:2
std::string_view is also common with 16*5 or 16^2*5; std::string even more with 11*7 or 11^1 *7
thinking on finding repeated occurrences of things, and identifying things that are one character off. then also thinking of finding repeated templates, and identifying things that are one character off. a repeated template handles more scenarios.
i guess a template is a sequence of constant strings separated by varying lengths of non-matching data increases the brute-force space to consider varying lengths. likely there are regions of that space that are far more interesting than others. basically, you'd look for two-sequence templates, then three-sequence templates, etc. for each interesting string. the fact that only strings that already repeat matter, seriously reduces the brute force space.
basically, when you find a match, you'd start search for further matches that occur strictly after existing matches. i guess it makes sense to let it find all the matches first, then to look for further matches that occur after them. and basically to repeat this for further parts.
class Reference: def __init__(self, class SimpleLogicalThing: # let's express truth that the number one is one # 1 is a concept that is convertible to an integer # equality refers to parts of a concept that are held with shared value in a context # so, maybe we'll need: concepts, integer concepts, # how to keep it small?
ok let's assume the context. basically, the set of stuff that's considered, is the context. say we're in the context of integers. now our items are integers. class Item(int): pass and equality is the equal operator def Equals(a, b): return a == b Is this too defined? Not abstracted enough?
Something consistent. That doesn't go all weird. So that means using data storage to retain information consistently.
# 1. load from data storage class ConsistentContext: def __init__(self, filename): self.filename = filename self._load() def _load(self): try: with open(self.filename, 'rt') as file: self.data = [eval(line) for line in file] except: print(f'making {self.filename} new') def save(self): with open(self.filename + '.tmp', 'rt') as file: for idx, line in enumerate(data): if idx > 0: file.write('\n') file.write(repr(line)) def __del__(self): self.save()
# 1. load from data storage class ConsistentContext: def __init__(self, filename): self.filename = filename self._load() def _load(self): try: with open(self.filename, 'rt') as file: self.data = [eval(line) for line in file] except: print(f'making {self.filename} new') self.data = [] self.save() def save(self): with open(self.filename + '.tmp', 'rt') as file: for idx, line in enumerate(self.data): if idx > 0: file.write('\n') file.write(repr(line)) def __del__(self): self.save()
by nice to slightly change to not use eval() and repr() so it is easy to rewrite in other languages. can be the thing for now though. may find it here again!
particle systems are something i am still trying to do again, to make use of structures and graphics. text mode particle system draft, python i'll use a normal structure, even though they are slow in python. class Particle: def __init__(self, x, y, duration, xv = 0, yv = 0): self.x = x self.y = y self.t = duration self.xv = xv self.yv = yv def update(self, time): self.x += self.xv * time self.y += self.yv * time self.t -= duration return self.t >= 0 class ParticleGenerator: def __init__(self)
class Particle: def __init__(self, x, y, duration, xv = 0, yv = 0): self.x = x self.y = y self.t = duration self.xv = xv self.yv = yv def update(self, time): self.x += self.xv * time self.y += self.yv * time self.t -= duration return self.t >= 0 class ParticleGenerator: def __init__(self, rate): self.particles = [] self.rate = rate self.time_modulus = 0 def update(self, time): new_particle_count =
class Particle: def __init__(self, x, y, duration, xv = 0, yv = 0): self.x = x self.y = y self.t = duration self.xv = xv self.yv = yv def update(self, time): self.x += self.xv * time self.y += self.yv * time self.t -= duration return self.t >= 0 class ParticleGenerator: def __init__(self, rate): self.particles = [] self.rate = rate self.time_modulus = 0 def update(self, time): # i'd like to check the constant rate logic in this line new_particle_count, self.time_modulus = divmod(time + self.time_modulus, self.rate) for idx, particle in self.particles:
---------------------- structure generator def StructureGenerator def __init__(self): self.generated = [] def update(self, time): self.generated.append(self.new_structure()) for structure in self.generated: structure.update(time) def new_structure(self): # override return self.Structure()
---------------------- structure generator that reuses spots def StructureGenerator def __init__(self): self.generated = [] def update(self, time): num_generated = 0 num_to_generate = 1 for idx, structure in enumerate(self.generated): if structure is None or not structure.update(time): if num_generated < num_to_generate: self.generated[idx] = self.new_structure() else: self.generated[idx] = None while num_generated < num_to_generate: self.generated.append(self.new_structure()) def new_structure(self): # override return self.Structure()
This is the 'triangle' thread. For some reason a new thread happened in my UI. class Particle: def __init__(self, x, y, duration, xv = 0, yv = 0): self.x = x self.y = y self.t = duration self.xv = xv self.yv = yv def update(self, time): self.x += self.xv * time self.y += self.yv * time self.t -= duration return self.t >= 0 class ParticleGenerator: def __init__(self, rate): self.particles = [] self.rate = rate self.time_modulus = 0 def update(self, time): # i'd like to check the constant rate logic in this line new_particle_count, self.time_modulus = divmod(time + self.time_modulus, self.rate) new_particles_made = 0 for idx, particle in enumerate(self.particles): if particle is None or not particle.update(time): if new_particles_made < new_particle_count: self.particles[idx] = self.new_particle() else: self.particles[idx] = None while new_particles_made < new_particle_count: self.particles.append(self.new_particle())
class Particle: def __init__(self, x, y, duration, xv = 0, yv = 0, bounds): self.x = x self.y = y self.t = duration self.xv = xv self.yv = yv def update(self, time): self.x += self.xv * time self.y += self.yv * time self.t -= duration return self.t >= 0 class ParticleGenerator: def __init__(self, rate): self.particles = [] self.rate = rate self.time_modulus = 0 def update(self, time): # i'd like to check the constant rate logic in this line new_particle_count, self.time_modulus = divmod(time + self.time_modulus, self.rate) new_particles_made = 0 for idx, particle in enumerate(self.particles): if particle is None or not particle.update(time): if new_particles_made < new_particle_count: self.particles[idx] = self.new_particle() else: self.particles[idx] = None while new_particles_made < new_particle_count: self.particles.append(self.new_particle()) import random class CharacterFountain(ParticleGenerator): def __init__(self, character = '*', gravity = 9.8, fountain_strength = 10, width=80, height=25, character_aspect = 0.5): self.character = character self.gravity = gravity self.rows = height self.cols = width i'd like to calculate the maximum x velocity of a particle that starts at the bottom center of the view rectangle, so as to reach the outer corner when it lands, by solving the parabola def new_particle(self): return self.Particle(self) class Particle(Particle): def __init__(self, fountain): self.fountain = fountain super().__init__((fountain.rows-1) / 2, fountain.cols - 1,
----------------------------- parabola solving. p0 = x0,y0 = (0,0) a = 0,g v0 = v_x,v0_y
----------------------------- parabola solving. p0 = x0,y0 = (0,0) a = 0,g v0 = v_x,v0_y v = v0 + a v_x = v0_x + a_x v_y = v0_y + a_y v(t) = v
----------------------------- parabola solving. p(0) = x0,y0 = (0,0) a(t) = 0,-g v(0) = v0_x,v0_y v(t) = v(0) + a(t) * t v(t)_x = v0_x + a_x * t v(t)_y = v0_y + a_y * t
----------------------------- parabola solving. p(0) = x0,y0 = (0,0) a(t) = 0,-g v(0) = v0_x,v0_y v(t) = v(0) + a(t) * t v(t)_x = v0_x + a_x * t v(t)_y = v0_y + a_y * t p_y(t) = p_y(0) + integral(v_y(t),t,0,t) p_x(t) = p_x(0) + integral(v_x(t),t,0,t)
----------------------------- parabola solving. p(0) = x0,y0 = (0,0) a(t) = 0,-g v(0) = v0_x,v0_y v(t) = v(0) + a(t) * t v(t)_x = v0_x + a_x * t v(t)_y = v0_y + a_y * t p_y(t) = p_y(0) + integral(v_y(t),t,0,t) p_x(t) = p_x(0) + integral(v_x(t),t,0,t) integral(v_y(t),t,0,t) = integral(v_0y + a_y * t) = v_0y + integral(a_y *t, 0, t)
---- integral of xt dt might make whole problem much simpler integration increases power and reduces coefficient integral(xt,t) = 1/2 xt^2
----------------------------- parabola solving. p(0) = x0,y0 = (0,0) a(t) = 0,-g v(0) = v0_x,v0_y v(t) = v(0) + a(t) * t v(t)_x = v0_x + a_x * t v(t)_y = v0_y + a_y * t p_y(t) = p_y(0) + integral(v_y(t),t,0,t) p_x(t) = p_x(0) + integral(v_x(t),t,0,t) integral(v_y(t),t,0,t) = integral(v_0y + a_y * t) = v_0y + integral(a_y *t, 0, t) integral(xt,t) = 1/2 xt^2 integral(a_y t, 0, t) = 1/2 a_y t^2
----------------------------- parabola solving. p(0) = x0,y0 = (0,0) a(t) = 0,-g v(0) = v0_x,v0_y v(t) = v(0) + a(t) * t v(t)_x = v0_x + a_x * t v(t)_y = v0_y + a_y * t p_y(t) = p_y(0) + integral(v_y(t),t,0,t) p_x(t) = p_x(0) + integral(v_x(t),t,0,t) integral(v_y(t),t,0,t) = integral(v_0y + a_y * t) = v_0y + a_y t^2 / 2 integral(v_x(t),t,0,t) = v_0x + a_x t^2 / 2
----------------------------- parabola solving. p(0) = x0,y0 = (0,0) a(t) = 0,-g v(0) = v0_x,v0_y v(t) = v(0) + a(t) * t v(t)_x = v0_x + a_x * t v(t)_y = v0_y + a_y * t p_y(t) = p_y(0) + v_y(0) * t + a_y(t) t^2 / 2 p_x(t) = p_x(0) + v_x(0) * t + a_x(t) t^2 / 2 i considered the lines a bit by imagining how they would draw a chart, and realised velocity needed to be multiplied by time. has been added.
----------------------------- parabola solving. p(0) = x0,y0 = (0,0) a(t) = 0,-g v(0) = v0_x,v0_y v(t) = v(0) + a(t) * t v(t)_x = v0_x + a_x * t v(t)_y = v0_y + a_y * t p_y(t) = p_y(0) + v_y(0) * t + a_y(t) t^2 / 2 p_x(t) = p_x(0) + v_x(0) * t + a_x(t) t^2 / 2 p_y(t) = 0 + v_y(0) * t - g t^2 / 2 p_x(t) = 0 + v_x(0) * t
----------------------------- parabola solving. p_y(t) = 0 + v_y(0) * t - g t^2 / 2 p_x(t) = 0 + v_x(0) * t -> first find t_f, when p_y = 0 again -> then find v_x(0) in terms of t_f maybe !
----------------------------- parabola solving. p_y(t) = 0 + vy * t - g t^2 / 2 p_x(t) = 0 + vx * t quadratic equation for p_y(t_f) = 0. ax^2 + bx + c a = -g b = vy (t_0, t_f) = [-b +- sqrt(b^2 - 4ac)] / 2a
----------------------------- parabola solving. p_y(t) = 0 + vy * t - g t^2 / 2 p_x(t) = 0 + vx * t quadratic equation for p_y(t_f) = 0. ax^2 + bx + c a = -g b = vy (t_0, t_f) = [-b +- sqrt(b^2 - 4ac)] / 2a (t_0, t_f) = [-vy +- sqrt(vy^2)] / -2g t_f = (-vy - vy) / -2g t_f = vy / g
simulate to test. p_y(t) = 0 + vy * t - g t^2 / 2 p_x(t) = 0 + vx * t t_f = vy / g v_x = p_x(t_f) / t_f = p_x(t_f) * g / vy
class Particle: def __init__(self, x, y, duration, xv = 0, yv = 0, bounds): - Hide quoted text - self.x = x self.y = y self.t = duration self.xv = xv self.yv = yv def update(self, time): self.x += self.xv * time self.y += self.yv * time self.t -= duration return self.t >= 0 class ParticleGenerator: def __init__(self, rate): self.particles = [] self.rate = rate self.time_modulus = 0 def update(self, time): # i'd like to check the constant rate logic in this line new_particle_count, self.time_modulus = divmod(time + self.time_modulus, self.rate) new_particles_made = 0 for idx, particle in enumerate(self.particles): if particle is None or not particle.update(time): if new_particles_made < new_particle_count: self.particles[idx] = self.new_particle() else: self.particles[idx] = None while new_particles_made < new_particle_count: self.particles.append(self.new_particle()) import random class CharacterFountain(ParticleGenerator): def __init__(self, character = '*', gravity = 9.8, fountain_strength = 10, width=80, height=25, character_aspect = 0.5): self.character = character self.gravity = gravity self.rows = height self.cols = width # simulate to test # p_y(t) = 0 + vy * t - g t^2 / 2 # p_x(t) = 0 + vx * t # t_f = vy / g # v_x = p_x(t_f) / t_f = p_x(t_f) * g / vy # i'd like to calculate the maximum x velocity of a particle that starts at the bottom center # of the view rectangle, so as to reach the outer corner when it lands, by solving the parabola def new_particle(self): return self.Particle(self) class Particle(Particle): def __init__(self, fountain): self.fountain = fountain super().__init__((fountain.rows-1) / 2, fountain.cols - 1,
https://github.com/xloem/log/blob/wip/multicapture.py#L14L29 # indexes a balanced tree of past indices class append_indices(list): def __init__(self, degree = 2, initial_indices = []): super().__init__(*initial_indices) self.degree = degree self.leaf_count = 0 def append(self, last_indices_id): self.leaf_count += 1 leaf_count = self.leaf_count idx = 0 for idx, (sub_leaf_count, value) in enumerate(self): if sub_leaf_count * self.degree <= leaf_count: break leaf_count -= sub_leaf_count idx += 1 # to append if the loop falls through self[idx:] = [(leaf_count, last_indices_id)] I am quite satisfied and proud of putting this together. It produces a balanced binary tree from append-only data like the dat project's protocol, but is only a handful of lines long and uses few operations. I made it to try to draft another cryptographic livestreaming system. Still haven't quite reached workability yet. It does _not_ include random writes as pursued in the other thread for a bit, which i decided i wanted to do by organizing trees to be deepest away from recent writes. The theory is quite similar, of used indices obscuring the content of deeper indices, keeping the depth of the tree bounded even when including references to deeper leaves. When I was making it, I was in one of my confusing situations where I was using an offline terminal with a working keyboard via serial cable to connect to a raspberry pi without a keyboard where i used mosh over yggdrasil to connect to a firewalled remote system that had more resources than local things. Something had started going wrong with the network or possibly remote i/o, and keystrokes were very slow. The algorithm was quite hard for me to think about, and the delay with keystrokes was making it harder. I disconnected from all the things, and tried hard to draft it locally. I had struggle-fun with it, and kept reorganising it until it got small. I worked on it inside a local tmux session, so I then opened up the serial terminal and mosh again from within the local tmux session, and used tmux's buffer support to copy the text over. The end result actually works; I blockchained some audio from an android phone, and after a lot of dev attempts downloaded the audio again off a network peer, and reconstructed it from the index trees, and played it. However, the upload process was too slow, and most of the content was lost from recording overrun; the download contained only interspersed brief clear snippets of audio pasted together. Still, so close!! and it's enough to prove something happened from your phone. It runs in tmux and uses the android audio hardware.
i realized random writes may be as simple as applying the same algorithm to the left and right edges of each unwritten region. this means implementing region bounds. i got as far as below before overwhelming dyskinesia. https://github.com/xloem/flat_tree append_indices.py # indexes a balanced tree of past indices # every write, publish a .copy() paired with data, then pass the locator to .append() to index it class append_indices(list): def __init__(self, degree = 2, initial_indices = []): super().__init__(*initial_indices) self.degree = degree self.leaf_count, self.size = 0, 0 for leaf_count, size, value in self: self.leaf_count += leaf_count self.size += size def append(self, added_size, last_publish): self.leaf_count += 1 self.size += added_size new_leaf_count = self.leaf_count new_size = self.size for idx, (branch_leaf_count, branch_size, branch_id) in enumerate(self): if branch_leaf_count * self.degree <= new_leaf_count: break new_leaf_count -= branch_leaf_count new_size -= branch_size else: idx = len(self) self[idx:] = [(new_leaf_count, new_size, last_publish)] mix_indices.py class append_indices(list): def __init__(self, degree = 2, initial_indices = []): super().__init__(*initial_indices) self.degree = degree self.degree = degree self.leaf_count, self.size = 0, 0 for leaf_count, size, value in self: self.leaf_count += leaf_count self.size += size self.splice_queue = [] def _insert(self, last_publish, *ordered_splices): # a reasonable next step is to provide for truncation appends, where a tail of the data is replaced with new data # currently only performs 1 append assert len(ordered_splices) == 1 for spliced_out_start, spliced_out_stop, spliced_in_size in ordered_splices: #assert spliced_out_start == self.size # truncation appends are drafted but untested assert spliced_out_stop == self.size self.leaf_count += 1 self.size += spliced_in_size new_leaf_count = self.leaf_count new_offset = 0 for idx, (branch_leaf_count, branch_offset, branch_size, branch_id) in enumerate(self): if branch_leaf_count * self.degree <= new_leaf_count: break new_leaf_count -= branch_leaf_count new_offset += branch_size else: idx = len(self) self[idx:] = ((new_leaf_count, new_offset, spliced_out_start + spliced_in_size - new_offset, last_publish),) def append(self, last_publish, added_size): self._insert(last_publish, (self.size, self.size, added_size)) def snap(self, data): return (self.copy(), data) test.py from mix_indices import append_indices index = append_indices(degree=3) stored_indices = {} import random data = [random.randbytes(random.randint(1,8)) for x in range(24)] for chunk in data: id = index.leaf_count stored_indices[id] = (index.copy(), chunk) index.append(id, len(chunk)) def iterate(index, start_offset, end_offset): subendoffset = 0 for subleafcount, suboffset, subsize, subid in index: subindex, subdata = stored_indices[subid] subendoffset += subsize if subendoffset > start_offset: data = b''.join(iterate(subindex, start_offset, end_offset)) yield data if subendoffset > end_offset: return yield subdata start_offset = subendoffset data = b''.join(data) print(data) cmp = b''.join(iterate(index, 0, index.size)) print(cmp) assert data == cmp print(index)
On Tue, May 24, 2022, 7:38 PM punk <punks@tfwno.gf> wrote:
On Tue, 24 May 2022 18:02:14 -0400 Karl Semich <0xloem@gmail.com> wrote:
came up with new idea of triangle but don't remember what is
HEY FUCKING ASSHOLE, STOP SPAMMING.
HEY FUCKING WONDERFUL PERSON, want to learn a programming language with me? what languages do you like? I started programming in 2nd grade, my mother said I didn't even know how to read before this. I'd be happy to help you learn.
On Wed, 25 May 2022 04:28:01 -0400 Karl Semich <0xloem@gmail.com> wrote:
On Tue, May 24, 2022, 7:38 PM punk <punks@tfwno.gf> wrote:
On Tue, 24 May 2022 18:02:14 -0400 Karl Semich <0xloem@gmail.com> wrote:
came up with new idea of triangle but don't remember what is
HEY FUCKING ASSHOLE, STOP SPAMMING.
HEY FUCKING WONDERFUL PERSON, want to learn a programming language with me? what languages do you like?
I have a better idea. Why don't you direct your spamming attack to pro2rat@yahoo.com.au? Every time that thing sends government propaganda to the list, you reply to it and point out all the lies. I mean, that's what you would do if you were an actual 'cypherpunk' and not a government agent like pro2rat@yahoo.com.au.
:
On Tue, 24 May 2022 18:02:14 -0400 Karl Semich <0xloem@gmail.com> wrote:
HEY FUCKING WONDERFUL PERSON, want to learn a programming language with me? what languages do you like?
Karl, I don't think anyone can learn anything from you. Because you're sending spam e-mails here. People here don't need to develop coding skills. If you want to improve a lot, there are a lot of groups you can do common projects
The e-mails you send here are a bunch of meaningless stacks. Do you have a project or a github account?Can you build reusable code or libraries ? There are only meaningless ASCII textings here.
zeynep, I received an email from you that isn't making sense to me. On 5/25/22, zeynep@keemail.me <zeynep@keemail.me> wrote:
:
On Tue, 24 May 2022 18:02:14 -0400 Karl Semich <0xloem@gmail.com> wrote:
HEY FUCKING WONDERFUL PERSON, want to learn a programming language with me? what languages do you like?
Karl, I don't think anyone can learn anything from you. Because you're sending spam e-mails here.
The [spam] tag is a joke. I'm not trying to attack. I'm trying to be easy to filter.
People here don't need to develop coding skills. If you want to improve a
Why would you say this? This is the cypherpunks list, and software technology is always developing.
lot, there are a lot of groups you can do common projects.
I guess that sounds like a helpful idea :) This is one of them, of course.
The e-mails you send here are a bunch of meaningless stacks. Do you have a
I'm not sure you mean "stack" here. This code isn't very stack intensive.
project or a github account?Can you build reusable code or libraries ?
My most recent library is https://github.com/xloem/pyarweave .
There are only meaningless ASCII textings here.
It is strange to hear this said. Most code is in ASCII, although UTF-8 code is definitely cool.
punk, I received an email from you that isn't making sense to me.
HEY FUCKING ASSHOLE, STOP SPAMMING.
HEY FUCKING WONDERFUL PERSON, want to learn a programming language with me? what languages do you like?
I have a better idea. Why don't you direct your spamming attack to
The [spam] tag is a joke. I'm not trying to attack. I'm trying to be easy to filter.
pro2rat@yahoo.com.au? Every time that thing sends government propaganda to the list, you reply to it and point out all the lies. I mean, that's what you would do if you were an actual 'cypherpunk' and not a government agent like pro2rat@yahoo.com.au.
I am imagining that a cypherpunk would block pro2rat. It has not seemed to productive to reply to any of you. I am available to teach or learn to code with you, in this thread. That is what I am available to do here. In other threads, I am more available for other things.
On Wed, 25 May 2022 14:24:16 -0400 "Undiscussed Horrific Abuse, One Victim of Many" <gmkarl@gmail.com> wrote:
I am imagining that a cypherpunk would block pro2rat.
nah, cypherpunks wouldn't run a list that is 99% government propaganda.
It has not seemed to productive to reply to any of you.
lawl YOU FUCKING ASSHOLE, there's nothing 'productive' about you and your posting on this list. YOU are not 'productive' because you are a government agent.
participants (4)
-
Karl Semich -
punk -
Undiscussed Horrific Abuse, One Victim of Many -
zeynep＠keemail.me