At the origin of language structure

Science Daily ^ | 8/27/2015 | Sissa Medialab

[JimSEA]

There are languages that place the verb between the subject and the object (SVO order -- Subject/ Verb/ Object) while others place it at the end of the trio (SOV order). The order of these elements, far from being purely decorative, influences efficiency of expression. A team from SISSA's Language, Cognition and Development Lab (along with two Iranian institutions) studied the mechanism that controls the transition from the SOV form, considered the "basic" order by scientists, to the SVO order while the language is evolving, demonstrating that when the computational load on the brain is lightened, humans choose more efficient systems of communication which encourage the use of more complex grammatical structures.

[JoeFromSidney]

It’s really just reverse polish notation, only for language.

That was my first reaction, too.

[lurked_for_a_decade]

LALR(1) BNF grammer for the C programming language

%token int_const char_const float_const id string enumeration_const
%%

translation_unit : external_decl
| translation_unit external_decl
;
external_decl : function_definition
| decl
;
function_definition : decl_specs declarator decl_list compound_stat
| declarator decl_list compound_stat
| decl_specs declarator compound_stat
| declarator compound_stat
;
decl : decl_specs init_declarator_list ‘;’
| decl_specs ‘;’
;
decl_list : decl
| decl_list decl
;
decl_specs : storage_class_spec decl_specs
| storage_class_spec
| type_spec decl_specs
| type_spec
| type_qualifier decl_specs
| type_qualifier
;
storage_class_spec : ‘auto’ | ‘register’ | ‘static’ | ‘extern’ | ‘typedef’
;
type_spec : ‘void’ | ‘char’ | ‘short’ | ‘int’ | ‘long’ | ‘float’
| ‘double’ | ‘signed’ | ‘unsigned’
| struct_or_union_spec
| enum_spec
| typedef_name
;
type_qualifier : ‘const’ | ‘volatile’
;
struct_or_union_spec : struct_or_union id ‘{’ struct_decl_list ‘}’
| struct_or_union ‘{’ struct_decl_list ‘}’
| struct_or_union id
;
struct_or_union : ‘struct’ | ‘union’
;
struct_decl_list : struct_decl
| struct_decl_list struct_decl
;
init_declarator_list : init_declarator
| init_declarator_list ‘,’ init_declarator
;
init_declarator : declarator
| declarator ‘=’ initializer
;
struct_decl : spec_qualifier_list struct_declarator_list ‘;’
;
spec_qualifier_list : type_spec spec_qualifier_list
| type_spec
| type_qualifier spec_qualifier_list
| type_qualifier
;
struct_declarator_list : struct_declarator
| struct_declarator_list ‘,’ struct_declarator
;
struct_declarator : declarator
| declarator ‘:’ const_exp
| ‘:’ const_exp
;
enum_spec : ‘enum’ id ‘{’ enumerator_list ‘}’
| ‘enum’ ‘{’ enumerator_list ‘}’
| ‘enum’ id
;
enumerator_list : enumerator
| enumerator_list ‘,’ enumerator
;
enumerator : id
| id ‘=’ const_exp
;
declarator : pointer direct_declarator
| direct_declarator
;
direct_declarator : id
| ‘(’ declarator ‘)’
| direct_declarator ‘[’ const_exp ‘]’
| direct_declarator ‘[’ ‘]’
| direct_declarator ‘(’ param_type_list ‘)’
| direct_declarator ‘(’ id_list ‘)’
| direct_declarator ‘(’ ‘)’
;
pointer : ‘*’ type_qualifier_list
| ‘*’
| ‘*’ type_qualifier_list pointer
| ‘*’ pointer
;
type_qualifier_list : type_qualifier
| type_qualifier_list type_qualifier
;
param_type_list : param_list
| param_list ‘,’ ‘...’
;
param_list : param_decl
| param_list ‘,’ param_decl
;
param_decl : decl_specs declarator
| decl_specs abstract_declarator
| decl_specs
;
id_list : id
| id_list ‘,’ id
;
initializer : assignment_exp
| ‘{’ initializer_list ‘}’
| ‘{’ initializer_list ‘,’ ‘}’
;
initializer_list : initializer
| initializer_list ‘,’ initializer
;
type_name : spec_qualifier_list abstract_declarator
| spec_qualifier_list
;
abstract_declarator : pointer
| pointer direct_abstract_declarator
| direct_abstract_declarator
;
direct_abstract_declarator: ‘(’ abstract_declarator ‘)’
| direct_abstract_declarator ‘[’ const_exp ‘]’
| ‘[’ const_exp ‘]’
| direct_abstract_declarator ‘[’ ‘]’
| ‘[’ ‘]’
| direct_abstract_declarator ‘(’ param_type_list ‘)’
| ‘(’ param_type_list ‘)’
| direct_abstract_declarator ‘(’ ‘)’
| ‘(’ ‘)’
;
typedef_name : id
;
stat : labeled_stat
| exp_stat
| compound_stat
| selection_stat
| iteration_stat
| jump_stat
;
labeled_stat : id ‘:’ stat
| ‘case’ const_exp ‘:’ stat
| ‘default’ ‘:’ stat
;
exp_stat : exp ‘;’
| ‘;’
;
compound_stat : ‘{’ decl_list stat_list ‘}’
| ‘{’ stat_list ‘}’
| ‘{’ decl_list ‘}’
| ‘{’ ‘}’
;
stat_list : stat
| stat_list stat
;
selection_stat : ‘if’ ‘(’ exp ‘)’ stat
| ‘if’ ‘(’ exp ‘)’ stat ‘else’ stat
| ‘switch’ ‘(’ exp ‘)’ stat
;
iteration_stat : ‘while’ ‘(’ exp ‘)’ stat
| ‘do’ stat ‘while’ ‘(’ exp ‘)’ ‘;’
| ‘for’ ‘(’ exp ‘;’ exp ‘;’ exp ‘)’ stat
| ‘for’ ‘(’ exp ‘;’ exp ‘;’ ‘)’ stat
| ‘for’ ‘(’ exp ‘;’ ‘;’ exp ‘)’ stat
| ‘for’ ‘(’ exp ‘;’ ‘;’ ‘)’ stat
| ‘for’ ‘(’ ‘;’ exp ‘;’ exp ‘)’ stat
| ‘for’ ‘(’ ‘;’ exp ‘;’ ‘)’ stat
| ‘for’ ‘(’ ‘;’ ‘;’ exp ‘)’ stat
| ‘for’ ‘(’ ‘;’ ‘;’ ‘)’ stat
;
jump_stat : ‘goto’ id ‘;’
| ‘continue’ ‘;’
| ‘break’ ‘;’
| ‘return’ exp ‘;’
| ‘return’ ‘;’
;
exp : assignment_exp
| exp ‘,’ assignment_exp
;
assignment_exp : conditional_exp
| unary_exp assignment_operator assignment_exp
;
assignment_operator : ‘=’ | ‘*=’ | ‘/=’ | ‘%=’ | ‘+=’ | ‘-=’ | ‘<<=’
| ‘>>=’ | ‘&=’ | ‘^=’ | ‘|=’
;
conditional_exp : logical_or_exp
| logical_or_exp ‘?’ exp ‘:’ conditional_exp
;
const_exp : conditional_exp
;
logical_or_exp : logical_and_exp
| logical_or_exp ‘||’ logical_and_exp
;
logical_and_exp : inclusive_or_exp
| logical_and_exp ‘&&’ inclusive_or_exp
;
inclusive_or_exp : exclusive_or_exp
| inclusive_or_exp ‘|’ exclusive_or_exp
;
exclusive_or_exp : and_exp
| exclusive_or_exp ‘^’ and_exp
;
and_exp : equality_exp
| and_exp ‘&’ equality_exp
;
equality_exp : relational_exp
| equality_exp ‘==’ relational_exp
| equality_exp ‘!=’ relational_exp
;
relational_exp : shift_expression
| relational_exp ‘<’ shift_expression
| relational_exp ‘>’ shift_expression
| relational_exp ‘<=’ shift_expression
| relational_exp ‘>=’ shift_expression
;
shift_expression : additive_exp
| shift_expression ‘<<’ additive_exp
| shift_expression ‘>>’ additive_exp
;
additive_exp : mult_exp
| additive_exp ‘+’ mult_exp
| additive_exp ‘-’ mult_exp
;
mult_exp : cast_exp
| mult_exp ‘*’ cast_exp
| mult_exp ‘/’ cast_exp
| mult_exp ‘%’ cast_exp
;
cast_exp : unary_exp
| ‘(’ type_name ‘)’ cast_exp
;
unary_exp : postfix_exp
| ‘++’ unary_exp
| ‘—’ unary_exp
| unary_operator cast_exp
| ‘sizeof’ unary_exp
| ‘sizeof’ ‘(’ type_name ‘)’
;
unary_operator : ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘~’ | ‘!’
;
postfix_exp : primary_exp
| postfix_exp ‘[’ exp ‘]’
| postfix_exp ‘(’ argument_exp_list ‘)’
| postfix_exp ‘(’ ‘)’
| postfix_exp ‘.’ id
| postfix_exp ‘->’ id
| postfix_exp ‘++’
| postfix_exp ‘—’
;
primary_exp : id
| const
| string
| ‘(’ exp ‘)’
;
argument_exp_list : assignment_exp
| argument_exp_list ‘,’ assignment_exp
;
const : int_const
| char_const
| float_const
| enumeration_const
;

[Diamond]

A csiscalal terhoem is ipannrtdedneet on the rsletdeeans of mtvaitioon and srcebtuuuls,

Cloilardy

[Verginius Rufus]

In Greek it's called "anacoluthon" if you change the syntax in mid-sentence...it is sometimes done to give the flavor of a real-life conversation where people often change their minds in mid-sentence as to what they want to say.

George W. Bush's critics did not realize he was using a sophisticated literary device when he asked "Is our children learning?"

[UCANSEE2]

But, I thought the study backed me up

Seems so.

except I could have misunderstood,

I think the only thing you misunderstood was my comment. I wasn't disagreeing with you, or the article.

[donna]

I wus confoosed.

[UCANSEE2]

I think we all are. The world no longer makes much sense.

[UCANSEE2]

Reminds me of COBOL.

Too much redundancy and variables defined that should be standard.

I had a teacher that explained it well.

In Assembler you tell the computer what to do.
In Fortran you ask it to do it.
In COBOL you get on your knees and beg.

[SunkenCiv]

Thanks JimSEA.

[Lonesome in Massachussets]

Whenever the literary German dives into a sentence, that is the last you are going to see of him till he emerges on the other side of his Atlantic with his verb in his mouth.

-Mark Twain

[Lonesome in Massachussets]

There is what is known as New Latin, words added to express ideas (like America) unknown to the original speakers. In general, Indo-European languages like Latin used verb second order, with whatever element of the sentence the speaker wished to stress first. Personal pronouns were eschewed, because you know from the form of the verb the person and number (but not gender) of the referent.

The English word “EXIT” is Latin for “[He, she, or it] goes out.” “Exit” and “Exeunt” (”They go out”) were used as stage directions in theatrical scripts, when characters left the stage. The word “Exit” was adopted by Americans to mean “egress”, the cousins keeping the less wieldly “Way Out”, though they seem to coming around.

[Pollster1]

Let's not forget the late lamented statesman, Canaan Banana, first President of Zimbabwe.

It's only after his demise that Zimbabwe became a banana republic.

[Pollster1]

We all knew that COBOL didn’t have a SNOBOL’s chance in Hades of surviving.

[Lurker]

Etymology ping. I know you’re long gone, but...

L

[BlueDragon]

Can you read this?

almost speedily

who needs punctuation

they tell me ancient Greek often was all upper-case lacking spaces between words

new words could be coined on the spot by way of combinations

that combining or joining of different words and fragments having it's own internalized rules of logic for doing so that carried additional grammatical sense

orsomethinglikethat icould bewayoff but you get my drift

[lurked_for_a_decade]

In mathematics, computer science, and linguistics, a formal language is a set of strings of symbols that may be constrained by rules that are specific to it.

The alphabet of a formal language is the set of symbols, letters, or tokens from which the strings of the language may be formed; frequently it is required to be finite.[1] The strings formed from this alphabet are called words, and the words that belong to a particular formal language are sometimes called well-formed words or well-formed formulas. A formal language is often defined by means of a formal grammar such as a regular grammar or context-free grammar, also called its formation rule.

The field of formal language theory studies primarily the purely syntactical aspects of such languages—that is, their internal structural patterns. Formal language theory sprang out of linguistics, as a way of understanding the syntactic regularities of natural languages. In computer science, formal languages are used among others as the basis for defining the grammar of programming languages and formalized versions of subsets of natural languages in which the words of the language represent concepts that are associated with particular meanings or semantics. In computational complexity theory, decision problems are typically defined as formal languages, and complexity classes are defined as the sets of the formal languages that can be parsed by machines with limited computational power. In logic and the foundations of mathematics, formal languages are used to represent the syntax of axiomatic systems, and mathematical formalism is the philosophy that all of mathematics can be reduced to the syntactic manipulation of formal languages in this way.

[Bigg Red]

I could read Zaneta’s paragraph quite easily. Yours I am still having troube with. Is it because the words in your example are not commongly used in everyday English? I made out what I think are “theorem” and “motivation”, but the rest are not coming to me. Need more context, I suppose.

[Bigg Red]

Very interesting. I do not enjoy reading like that, but if my work depended on reading a lot material in rapid manner, I would find that helpful, I suppose.

[Bigg Red]

https://www.youtube.com/watch?v=yTTrXAE7OPU

[Bigg Red]

troube = trouble