There are two periods where there are sharp declines: 19, and sometimes after 26, all the way to 35.

https://www.hallandalelaw.com/wp-content/uploads/2013/07/IIH...

If we assume, this is a indicator 'maturity', then the answer should be around 26-35, depending on the individual. It seems that the founding fathers were into something when the made the minimal age for a president at 35.

There is a reversal at 75+, but this is due to age related issues. And my experience from the older folks in my life, it seems people start reverting to a 'teenage' like state at 75+.

I hope things do get de-escalated soon, as this is not good for any party (apart Israel and Russia, which are the main gainers of all this mess).

They held the threat of closing it, as a deterrent of an attack, and once attacked, they did just that.

You either live in a parallel universe, or are just spewing here propaganda.

This war is only to benefit Israel, and right now indirectly Russia (due to the rising prices). Basically, the US is the main loser/sucker in this war, and we are all poorer for doing it.

"It certainly did not help that the United States had stood idle while the regime slaughtered tens of thousands of its opponents, before making the attempt,"

"Now, before we go forward, I want to clarify a few things. First, none of this is a defense of the Iranian regime, which is odious. That said, there are many odious regimes in the world and we do not go to war with all of them. Second, this is a post fundamentally about American strategy or the lack thereof and thus not a post"

Simple example:

Objective-C

if myObject {

}

in swift if myObject != nil {

}

Also opitionals in swift could have totally be avoided if they adopted a prototype based langue (basically object are never nil). Lua did this, and it is very elegant

But meanwhile, we got a half backed optional system, which is backwards (similiar to Java), and didn't help with the practicality of the language at all, and meanwhile you still can crash an app doing myArray[1]

Iran could have been contained and Obama was right on his approach. We don't know the details of the strikes, but I hope it doesn't go into a full blown war, but this will be another Iraq like disaster, and american people are getting tired of doing the bidding of Isreal, a country that is already mirred into doing a genocide. This war is already unpopular in pools. Iran's regime is terrible to its people, but this has the potential to be another disaster where countless of people could die.

I started my work on the J2ME era as well. Had to use textpad for development, and maybe eclipse at some point (which was pretty decent). Tools and simulators were all over the place.

BUT.... this is perfect for folks that want to use one monitor for both work, and as/for entertainment /just normal tv watching in a living room.

Now it is free and called eFootball... and obviously not that same, but PES has always been the favorite of fans gameplay wise.

I don't think this bodes well for the future. Both rats and bats have been huge vectors of diseases. This is going to produce some kind of super virus that will be another middle age plague like pandemic.

I have some data types (structs or objects), that I want to serialize, persist, and that they have some common attributes of behaviors.

In swift I can have each object to conform to Hashable, Identifiable, Codabele, etc etc... and keep repeating the same stuff over and over, or just create a base DataObject, and have the specific data object inherit it and just .

In swift you can do it by both protocols, (and extensions of them), but after a while they start looking exactly like object inheritance, and nothing like commposition.

Composition was preferred when many other languages didn't support object oriented out the gate (think Ada, Lua, etc), and tooling (IDEs) were primitive, but almost all modern languages do support it, and the tooling in insanely great.

Composition is great when you have behaviour that can be widely different, depending on runtime conditions. But, when you keep repeating yourself over and over by adopting the same protocols, perhaps you need some inheritance.

The one negative of inheretance is that when you change some behaviour of a parent class, you need to do more refactoring as there could be other classes that depend on it. But, again, with today's IDEs and tooling, that is a lot easier.

TLDR: Composition was preferred in a world where the languages didn't suport propper object inheretance out of the gate, and tooling and IDEs were still rudemmentary.