cttet

Because it is often closer to actual business logic.

Ludwig's fan interaction is still too para-social IMO, despite him trying to step away from it. In some sense Sykkyno would be a better example who actually distances himself really away from over interactions with fans and seems really in control of his life.

Have you heard of ECS? it seems quite close to the core idea.

Yep, the important question is how we should deal with it. Even if it is banned, somewhere people will be making it as well.

People would like to hunt and gather, but people will start farming eventually

Just for this argument: "Research shows that as many as 75 percent of personality test-takers receive a different result when tested again."

There is an easy counter: https://www.nature.com/articles/nature.2015.18248

The other two still holds for me though. But Big Five is not any better IMHO, it can be a trait for psychological health, but definitely not for personality.

I used it for a midi keyboard and it was fun

I think the love come from comparison for me. Among all the jobs that I have tried and known from people, mine is the most tolerable. So I love my job.

It depends on how much people's life saving is.. It can be even negative... not everyone is in your situation.

There are pragmatic reasons as well. For me, people spend a lot to be happy like buying luxurious stuff or go to the movies/good restaurant. Saving people makes me happy. I am willing to pay for my own happiness.

I personally really don’t care about this judgements. But an interesting thing to me is that all the claims are pointing to a category of people. I wonder why some people what to be categorised, like, even if “real programmer use vi”, why do I want to be a “real programmer” if I don’t like vi? What’s the charm of the arbitrary tag?

This sentence in the article quite contradict with itself: "In a culture obsessed with the right and wrong way of doing things" But it also have this negative sentiment towards culture and point out "the right and wrong way of doing things".

The only way for me to make it consistent is that it is a relative self-reflective view that "I am also part of the culture and this is destined to happen".

I think this depends on person. There are two levels of reading code, one is getting a rough idea of how the code flows and works, the other is to check all the details of the code. Some people are better at the prior and some are better at later.

What this refactoring essentially do is to segment code in natural language blocks. For people who process things in natural language concept blocks this makes it easier to get the general idea of how the function works at a glance and diving in the implementation of the inner functions later.

This will of course introduce the overhead that you have mentioned that will increase the time for you to process the detailed flow of code. But as far as I can see it is only an overhead and by spending some time (or smart IDE or a pencil) there will not be a fundamental problem.

For people that are good at reading raw code without the help of concept-based segmentation, they may not experience the benefit but only the overhead.

It have colours. Which is too much of visual stimulation IMO. I am OK if they are black and white.

"we don't want Rust generics to be Turing complete" Has good implications, like good IDE support

I tried google sheets(excels with lambda) for Aoc 2021 until like day 6 or 7, if I have lambdas it seems that I could move further though.

Otters have similar behaviours around fish: https://groups.google.com/g/alt.animals.otters/c/-0CUtw12haM

The core difference is that structs are static. Once a struct is defined the type are fixed. "composite types" here refers to type that can be dynamically changed when you annotate them. i.e. if you have an custom array type, you can compose them on the fly with MyArray[int] or MyArray[MyCat], structs can't do that.

If the type system is not powerful enough it will be extra works just to get around the inadequacy.. If c# have some support of sum type and structural subtyping like Python I will be using that... I mean even Haskell does not have proper records.. Python is not definitely the best, but quite nice among the current options.

My speculation is that because game industry know to design better UI patterns, they simply made better visual programming languages.

| Modules also bind data and functions together. Yep, but a module is still not a Class. My example was referring to you mixing concepts of Classes and Polymorphism and dynamic dispatch in your original reply.

As you said, there are a lot of object systems that are different, and the difference matters. Having inheritance or not matters. I was just making examples to show that things are different.

We all know that C++ concepts != go/typescript interfaces != Java/c# interfaces != Haskell type classes (c# concepts) != rust/scala traits.

Try to explain that using "CS literature", maybe a lot of language designs don't have a word yet made for that. Yep there are Subtyping, Bounded quantification, Ad hoc polymorphism, Row polymorphism, but still not enough to tell all of them from each other.

But to anyone in the community, people all know that they are all not Classes and what make them special is important. It is quite clear, but why don't you get that?

The concepts CS literature are quite trivial and people can spend a few weekends to learn, or maybe another few for type rule syntax or a few others for basic category theory to understand them in a more intuitive way. But the real problem of making a good language for some applications is still there and much more complex and difficult. And maybe current literature are not enough for that.

The elites will never dictate the words, the people will pick up whatever they want to express their knowledge anyway, as we know of what happened in history.

To me they are similar though. I used Python quite a lot, for string concatenation, I mostly use fstrings. `+` is used mostly in the `+=` case.

(a, b) would make more sense if then. Jokes aside, + also quite break the reading flows of the string such as

user_name + ": " + attr1 + "| " + attr2 + "\n"

is more difficult to parse by eyeball for me then

concat(user_name, ": ", attr1, "| ", attr2, "\n")

We could have sacrilegious Python version that put up all the stuffs lol. Such as multiline lambda :p here:

  def begin(\*args):
    return args[-1]

  begin(
      func := lambda x, y: begin(
          z := int(input()),
          x + y + z
      ),
      func(1, 2)
  )

not quite, since `a + b != b + a` feels a bit weird.

The big or small language problem have been debated quite a long time, for what I know especially in the scheme community. There are a lot of insightful discussions about R6RS, which you may find interesting.

What I meant is that the word "complicated" is vague. Even if you a using a language with dynamic type, it just hides the unavoidable complexity behind. All the problems with types will resurface at the run time. The language by itself allows very complex interactions with types, just that the user not specifying it. For me I would add the behaviour of the language as part of the language complexity, not the written part only.

Yep, so as I said the definition of things like "simple", "complex" are super vague.

| but using different syntax when doing different things can make a lot of sense.

For C users yes, if we step back a little bit, for English users yes, but for people with other language background it may not hold. Every pieces of added syntax will utilise some human priors that may be specific to someone. But some really minimal systems can be grasped by every background, albeit taking a very long time.

The natural language is evolved by people saying what they what and the majority became the language. Not defined by some elites or some authority.

Classes binds data and functions together, and object systems supports inheritance. These are some of the things that some people don't really like, but you may not care. People sometimes care about syntax as well, writing "Class" is also part of the experience of using the language.

We have different words in the language for a purpose, that's my opinion.

Yep but in this case a language should be bundled with a good tutorial that introduces everything nicely. But if a person wants to just look at the specifications and code examples, the person would be having a lot of pointless keys..

You can make a general claim like that and sounds true. But I was referring to how your general claim fits to the specific situation.

Conversation is mean to have a deliver and receive end, both side can have problems. "you miss the point" kind of push all the responsibility to the listener. But why you have such a strong confidence about your expression?

But I think that's the exact reason we need to learn simple languages here. So that we know the closed doors first (the abstraction problem), then we will create a key or find a key elsewhere. Otherwise if "Class" is made the part of the language, like Java, you will not appreciate the importance of it to any extent and have a overall bad experience....