There is that stereotype that french-speaking Swiss people speak slower than French ones. In my experience I find it valid, but maybe I am wrong.
If this is accurate, I am wondering if Swiss people transmit information at the same rate as French people.
It could be that they use more precise words on average, that convey more information, even if spoken more slowly, and keeping transmission rate identical. Or that body language, intonations are richer (non verbal).
Or the spoken transmission rate may actually be slower, but as the article describes, bottleneck is about structuring the ideas, and Swiss speakers, on average, may be more efficient/deliberate at that, instinctively/culturally.
I don't have enough experience speaking with Swiss nationals to verify my anecdotal theories... if anyone can chime in...
Tangentially, I'm relatively confident that what you're experience has provided you is simply confirmation bias. Unless French is not their first language.
WebOS was neat for sure but HP was never in a position to compete with Apple. More mobile device launches would simply have meant more money down the drain.
It's in human nature to need origin stories. Science's current one is the Big Bang. It is only a hypothesis and will never get to the next level of scientific rigor because it's impossible to test. I only believe in falsifiable theories. A good skeptic should realize the differences in scientific rigor and know that this is just a story with no truth behind it.
A well reasoned theory in any science should include and test for implications in the past and present. We can't just ignore time if we want a proper understanding of the universe.
Try to think of an object that doesn't exist, and isn't based on anything you've ever seen before, a completely new object with no basis in our reality. It's impossible.
Writers made elves by adding pointy ears to a human. That's it.
This is an outrageous thought experiment. Novelty is creating new connections or perceiving things in new ways, you can't just say "try to have eureka moment, see! impossible". You can't prompt engineer your own brain.
In fact, there's some research about eureka moments rewiring our brain. https://neurosciencenews.com/insight-memory-neuroscience-289...
First, my understanding of his points - a language is either a systems language like C or a scripting language like TCL or python. Systems language have "strong" types and are for data structures/algorithms, scripting languages are "typeless" and are for "gluing things together".
The main claim is that scripting languages are more concise and allow for faster development when gluing due to their 'typeless' nature.
In his example, he creates a button in Tcl.
button .b -text Hello! -font {Times 16} -command {puts hello}
He goes on to say:
With C++ and Microsoft Foundation Classes (MFC), it requires about 25 lines of code in three procedures. 1 Just set- ting the font requires several lines of code in MFC: CFont *fontPtr = new CFont(); fontPtr->CreateFont(16, 0, 0, 0, 700, 0, 0, 0, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, DEFAULT_PITCH|FF_DONTCARE, “Times New Roman”); buttonPtr->SetFont(fontPtr);
Much of this code is a consequence of the strong typ- ing[...] In Tcl, the essential characteristics of the font (typeface Times, size 16 points) can be used immediately with no declarations or conversions. Furthermore, Tcl allows the button’s behavior to be included directly in the command that cre- ates the button, while C++ and Java require it to be placed in a separately declared method.
End quote.
We've come a long way, and examples have made clear that this dichotomy is a false one. Ousterhout's view was colored by his limited experience, resulting in him misunderstanding what he actually likes about Tcl.
Let's talk about syntax. His exact Tcl code as presented could be parsed and compiled by a language that does static type analysis. It's not, because he's running it in an interpreter that only checks types at runtime. But the point is that whether code is compiled or interpreted is an implementation detail that has very little to do with the syntax. He likes his syntax because his syntax is obviously better than C++, nothing more.
And types: he claims that 'typeless' languages allow for faster development because of fewer restrictions. This is, ofc, nonsense. The amount of restrictions you have is a function of your problem, not your language. If it feels like dynamic typing is letting you develop faster, that's because you're putting off encountering those restrictions til later.
It's better to guarantee we encounter all type errors before the program even runs. But since you can do static type analysis for any language, why don't all languages do that?
Because it's hard. Type theory is complicated. Not all type systems are decidable, we need to pick one that is for practical reasons. Ones that are may require annotations or complex algorithms/semantics restrictions like Hindley-Milner.
As a PL designer, it's a whole lot easier to just give up and only check types at runtime. And that makes a whole lot of sense if your priority is just embedding a usable language ASAP. But let's not pretend that it's because it's actually better.
How often are you passing around data that you don't fully understand?
Also, people use types and then end up reaching for reflection to perform pattern matching on types at which point you've just moved the typing from the user level to a type system. Not much gained imo.
This is not so when it comes to the poor. Once in power they are no longer poor so the incentive to fix any issue related to this almost entirely evaporates.
There is a way to win an argument with a toddler. You find out what's bothering them, usually something emotional, and you validate it. "Yes! It's fun to stay up late! Yes! You don't want to eat your vegetables!" Once they feel heard, you've got a shot at getting them to do what you want.
That's a good way to win an argument with a non-toddler as well. Acknowledge that what they want is legitimate (if it is). Concede points of agreement. Talk about shared goals. Only then talk about a different path to the solution.
Native would be talking to the compositor directly.
GTK provides a cross-platform layer of abstractions over the compositor. That’s the opposite of native.
There’s countless bugs in the Linux port for applications (eg: Firefox) which can’t be fixed because of a he abstractions done by GTK.