The problem with society is that people are commonly selfish, so the majority of people only do things that benefit them. Children benefited ancient societies.
The problem with industrialized societies is that people lost all markers of adulthood. Everything became about worshiping convenience, and once convenience (for short-term pleasure) became "god", people wanted to avoid things they saw as unnecessarily difficult.
To reverse the trend, we need people to understand that the difficulty of life isn't a bad thing, that struggle and suffering aren't bad, they are essential for growth in becoming a better, happier person in the long run.
Would you rather be an ever-weakening wimp? Most people unconsciously say "yes", afraid of the world.
Kids are afraid of the chaos in life - suffering that happens when life throws you curve balls, like "what would I do without monetary support?". Even "adults" now are really kids are heart - afraid of losing social security, medicare, etc. "Welfare" programs don't end the dilemma - they only reinforce the childishness and dependency on gov for support.
We need more bold people, people who aren't afraid to suffer because they see the light at the end of the road. Courage separates the men from the boys.
> At "the end of the road" there's only death, so it's pointless to suffer just so you can make more people which will also suffer.
But sitting 8 hours a day in front of a rectangle emitting light and prompting llms to generate code for your overlords for the next 45 years definitely is not pointless
I am guessing you are from some reasonably developed country, you are so well unaware of how deeply biased the system is against most people in third world countries, the amount of suffering they experience is not for the faint of heart.
GP is a pampered 1st world baby simulating „difficulty” in his life because of decadent boredom, likely spending tens of thousands of dollars per year unnecessarily, living in an oversized dwelling with access to education, healthcare, plumbing, a robust justice system and a social safety net.
Oh look at that: the poster advocating for an effective, positive, and personal change instead of thrashing about in the status quo is downvoted. Imagine that. Personal responsibility is an anathema and we are doomed to this path for it.
What if it's through ad networks? Do the ad-networks pay or do they bill their users? Do they start offering the option, "exclude Maryland"?
It seems to me this would be really, really difficult to enforce. So much of what is digital doesn't come with tags. Ads may be relabeled "suggestions" to avoid laws.
Dubious. They're doing all they can to kill it with censorship. It takes more than just new tech to keep something afloat - you also have to treat your userbase well.
Hey, I thought Episode 1 was good. It was the only prequel that could stand on its own as a complete story. The others were "Oops, I forgot to plan this out better so let's just add a ton of fighting and action to hide that fact".
I really enjoyed Episode 1 when it came out, but it has some seriously... err.. controversial things, starting with the whole midichlorian thing and finishing with the over choreographed lightsaber fights[0].
The "Lucas can do no wrong" feels pretty present there too.
Actually, it can take multiple. gte(a: b: c: d:) is equivalent to (in C) a >= b && a >= c && a >= d. By making operators like functions, you can group like-operations and simplify code. Admittedly, it's not as readable for someone accustomed to seeing C style.
Last note: gte(a=100) would produce an error in Copper because a=100 is an assignment statement that returns "a" (a function), and gte( function ) means nothing.
Edit: I see you're referring to Python, but I figured I'd keep the note of comparison.
You are correct. "object-function" is basically like in Javascript: It's an object (having members) and an executable body. The colons are a shorthand for function call. ie myfunc()
In Copper, variables only store functions. This separates routine from data so you never end up with null pointer errors like in languages that have Any Types or pointers. Functions can return data, so you end up having function calls everywhere.
a=5 is basically a={ret(5)}
In your above example the correct first line would be:
adder = [a b] { ret(+(a: b:)) }
Parameters to a function are those that are not assigned data, whereas members are:
add = [Param, Member=10) { ret(+(Param: this.Member:)) }
Now you can probably see what's wrong with your third line.
Copper does not distinguish between function and object. An object-function has two parts: the member part and the executable body. In C++, it's analogous to:
Edit: The design of the parse tree is such that there is no need for things like statement termination, parameter separation, among other things. By its simplicity, the code focuses on what really matters. Complex syntax is mentally taxing and distracts the programmer from focusing his energy on problem solving.
> Complex syntax is mentally taxing and distracts the programmer from focusing his energy on problem solving.
With respect I don't see it that way (nor know of any studies to back that up qualitatively). While complex syntaxes do exist and they are horrible (I pray you never have to use XSLT) dropping semicolons and commas do not make a syntax noticeably simpler. But they may lay unexpected traps.
The dropping of semicolons and commas isn't what makes it simple, I'll agree. I was referring to the simplicity of the parse tree as a whole. It's easier to figure out what a Copper statement does because there are very few types of statements. Yes, there are a couple of traps [1]. Try reading this example [2] and see how you like it.
[1] When passing either an object or data to a function, the parameter is stored as a function. e.g. if f=[p]{}, then f(a) and f(5) have p=a and p=5 respectively. If a=5, then the results are identical. The trap is that if a={ret({ret(5)})}, which is a wrapping function, and you call "a" before passing it to "f", then you get the nested function {ret(5)} instead of the wrapping function {ret({ret(5)})}. Having worked with Copper in practice, it's not too hard to spot the error, but it is one of those things that will catch beginners off guard.
That "trap" looks weird. Does this mean that a's type changes somehow if you call it before passing it to f? That is indeed surprising for a statically typed language. Could you write out the types of the variants (wrapped vs. non-wrapped)?
a's type didn't change. The trap was that the wrapping function returned its nested function instead of itself. You can do the same thing in other languages, it's just easier to slip into code in Copper. Let me illustrate with pseudo C code:
[code]
class F {
int mydata;
F( int a ) : mydata(a) {}
F* operator( int p ) { a=p; return new Function(0); }
};
myF = new F(10);
doSomething( &myFunc );
doSomething( myFunc() );
[/code]
This is a basic formula for how things appear "under the hood" in the VM. Notice that doSomething() accepts F*, but in the first case, the F instance passed has a different mydata value. In Copper, the above code corresponds to:
That's still not very helpful to me. You might want to explain it a bit more in the README.
For example, taking this line from the first example:
this.peek = +(this.a: this.b:)
If I replace this by:
this.peek = +(this.a: this.b:
(note the dropped closing parenthesis) and leave everything else as is, that will not be a syntax error?
I know that Forth is "loose syntax" in that Forth code is just a sequence of white-space separated words, so your comment and mine are both syntactically valid Forth, but without meaningful semantics. But Forth does not use parenthesized function calls the way Copper does.
I see what you're getting at. Yes, a ) is needed... eventually. I think the key with "loose" is that it's forgiving. You won't encounter many syntax errors in average programming because the syntax has few rules. In that case, "very simple" would be better said than "loose".
The problem with industrialized societies is that people lost all markers of adulthood. Everything became about worshiping convenience, and once convenience (for short-term pleasure) became "god", people wanted to avoid things they saw as unnecessarily difficult.
To reverse the trend, we need people to understand that the difficulty of life isn't a bad thing, that struggle and suffering aren't bad, they are essential for growth in becoming a better, happier person in the long run.
Would you rather be an ever-weakening wimp? Most people unconsciously say "yes", afraid of the world. Kids are afraid of the chaos in life - suffering that happens when life throws you curve balls, like "what would I do without monetary support?". Even "adults" now are really kids are heart - afraid of losing social security, medicare, etc. "Welfare" programs don't end the dilemma - they only reinforce the childishness and dependency on gov for support.
We need more bold people, people who aren't afraid to suffer because they see the light at the end of the road. Courage separates the men from the boys.