The FORTH liberation

Bought my self two Arduinos (UNO and Mega) because, you know, you need to work with sensors and embedded little thingies. Also, you have to be able to fully grok a circuit, to understand the architecture, the assembly language, and so forth (pun intended). I bought a book about FORTH on the ATmega328P chipset, i.e., the heart of Arduino, by Dr. C.H. Ting, of eForth fame. It blew my mind. You wipe out the original bootloader and load FORTH on it. From that point on, you have full control, even stuff that the Arduino C compiler won't allow you to do. I'll just leave this quote here: "In explaining how this system is constructed, every step in the way, I hope to lay to rest these myths that computers are complicated, programming languages are complicated, and operating systems are complicated. All these things can be very simple, and can be understood by ordinary people and ordinary engineers. If you understand this 328eForth system completely, the understanding can be carried over to any computer and microcontrollers. People using computers are trained to be slaves. You are taught to push certain buttons, and you are taught to push certain keys. Then, you get employed to push buttons and keys to work as slaves. Computers, programming languages, and operating systems are made complicated to enslave people." -- C.H. Ting.

Lisp macros and why Smalltalk doesn't need them

Lisp is homoiconic and this allows for its powerfull macros. But there's two other languages that don't need macros (talking about the 'Big Old Languages', and not the manifold spawns): Smalltalk and Forth.

Here's a very insightful take on why Smalltalk doesn't need macros, by Richard Kenneth Eng:

"...macros make Lisp powerful because they allow you to write programs that themselves write programs. But that’s what macros are, not what enables them–Lisp’s macros aren’t the cause of its power, they’re a symptom of it. What makes Lisp powerful isn’t its macros, it’s the fact that Lisp runs in the same context it’s written in. It’s s-expressions all the way down. This leads to an interesting possibility: could there be other ways to achieve similar power? Are macros the only possible way to make programs that write programs, or might there be others?

Smalltalk goes one further than Lisp: it’s not that Smalltalk’s source code has no syntax so much as Smalltalk has no source code. “Source code,” after all, just means “program that isn’t running,” and there is no such thing as a Smalltalk program that isn’t running! Because there is absolutely nothing in Smalltalk except “data that runs”–which is what an object is, after all–then there is no distinction in Smalltalk between data and programs. Data (objects) can write programs (objects) which write data (objects) which write programs (objects) which… "

Getting the specs right is a fallacy (Lehman-Belady's Law)

"A classic study by Lehman and Belady identified several 'laws' of system change.

Continuing change > A program that is used in a real-world environment must change, or become progressively less useful in that environment.

Increasing complexity > As a program evolves, it becomes more complex, and extra resources are needed to preserve and simplify its structure

Studies have shown that more than half of total software budgets are devoted to 'software maintenance'. Furthermore, there are many claims that the cost of fixing errors in software projects goes up over time. This suggests that one should try to catch errors as early as possible, and perhaps one should invest more effort into 'getting requirements right'. The latter conclusion is a fallacy, however, if we recall that Lehman's laws tell us that requirements will always change."

-- From Oscar Nierstrasz, at a delicious Smalltalk course @  scg.unibe.ch/teaching/sma

-- See the Wikipedia article on Lehman's Law

THE SANTA CLARA PRINCIPLES ON ETHICAL CONTENT MODERATION

We live in an era of shadow banning and algorithmic banning of user-generated content on social media platforms.

It is a principle of Ethics, in my opinion, that the information content generated by an user in the Commons, belongs to the user. Think about medical records: it is widely recognized as and ethical and operational principle that the information belongs to the patient, and never to the entity that provides the service of care.

It has recently become an object of debate the fact that the big tech companies have taken upon themselves to act as "filters" for what they perceive are legitimate views - or not.

Likewise as in the case of patient records, I see no Ethical foundation for tech companies to take it upon themselves to "filter" or censor ideas, based on an algorithm that carries the design of the world view of those who design them (please go read about Project Veritas and the new Google algorithm.)

We have seen the encroaching tech-based censorship.  There was a time Google only did search, and a time where Twitter was for twitting. Now, tech companies want to shape society.

Some perceive censorship to be nice, as long as it doesn't reach YOU. However, we have hundreds of years of Philosophy to teach us that this is the slippery slope.

It is unacceptable that the flow of ideas or debates in the Commons be subject to the tech aristocracy.

It is a principle of Freedom and Democracy the right to the Free Expression of ideas. A Free and Open Society is a better society.

It is a principle of living that ideas be debated, and what you perceive to be wrong ideas must be debated even more.

Violence is reserved only for those who exert violence (e.g., the Nazi regime).

With more and more tech companies controlling the debate in the Commons, we must have clear ethical guidelines for this day and age.

The Santa Clara Principles on Content Moderation  is signed by, among others, the American Civil Liberties Union, the Electronic Frontiers Foundation.

Please read them. It's short.

Understand that neither Google, Facebook, YouTube or Twitter are acting in accordance to these guidelines. And be worried. Be very worried.

https://santaclaraprinciples.org/

Learning the Eiffel programming language takes a bit of effort

Learning the Eiffel programming language takes a bit of effort in 2019. Not that it's overly complicated (although it is sophisticated), but because there's just barely any documentation for newbies out there. No-one blogs about it. The Eiffel mindshare is very small, and this has to do with historical facts. When Eiffel was "hot," the Web, as we know it, didn't exist. Then C++ gained ground, parasitizing on C-oidness. Sun Microsystems soon followed, with a massive marketing campaign. This is partly the fault of Eiffel vendors, who didn't see the open source movement coming (the same thing happened to Smalltalk and Common Lisp).

Today, if you care to learn Eiffel, you must hunt for books. Then once you get them, you find out that the language spec has been updated, and you have to go through the code, trying to update it by looking at the current Eiffel classes documentation, Of course, Eiffel being Eiffel, this is totally doable, but not really easy sailing if you're a total beginner. 

A great place to start learning Eiffel in 2019

Eiffel ain't dead yet. It's used in Healthcare (I know this for a fact).

Here´s a pointer to start learning learning it, including how to write tests and start working with the awsome EiffelStudio.

BTW, it's 2019 and you can download EiffelStudio's GPL version. To be honest, the proprietary license is not horribly expansive (I asked the sales rep).

York University's Eiffel site

BON grammar - Business Object Notation

-- This grammar for the BON textual notation was extracted from the
-- text of the book "Seamless Object-Oriented Software Architecture"
-- and turned into plain Ascii format for easy use by anyone
-- interested in building a parser for the language.
--
-- For a general description of this notation and examples of its use,
-- see appendix A and B of the book, pp. 349-380.
--
-- The book text is freely available at http://www.bon-method.com.


-- BON SPECIFICATION
Bon_specification ::= {Specification_element ...}+
Specification_element ::= Informal_chart | Class_dictionary | Static_diagram |
    Dynamic_diagram | Notational_tuning

-- INFORMAL CHARTS
Informal_chart ::= System_chart | Cluster_chart | Class_chart |
    Event_chart | Scenario_chart | Creation_chart
Class_dictionary ::= 'dictionary' System_name
    {Dictionary_entry ...}+
    'end'
Dictionary_entry ::= 'class' Class_name 'cluster' Cluster_name
    'description' Manifest_textblock
--
System_chart ::= 'system_chart' System_name
    ['indexing' Index_list]
    ['explanation' Manifest_string]
    ['part' Manifest_string]
    [Cluster_entries]
    'end'
Cluster_entries ::= {Cluster_entry ...}+
Cluster_entry ::= 'cluster' Cluster_name
    'description' Manifest_textblock
System_name ::= Identifier
--
Index_list ::= {Index_clause ";" ...}+
Index_clause ::= Identifier ":" Index_term_list
Index_term_list ::= {Index_string "," ...}+
Index_string ::= Manifest_string
--
Cluster_chart ::= 'cluster_chart' Cluster_name
    ['indexing' Index_list]
    ['explanation' Manifest_string]
    ['part' Manifest_string]
    [Class_entries]
    [Cluster_entries]
    'end'
Class_entries ::= {Class_entry ...}+
Class_entry ::= 'class' Class_name
    'description' Manifest_textblock
Cluster_name ::= Identifier
--
Class_chart ::= 'class_chart' Class_name
    ['indexing' Index_list]
    ['explanation' Manifest_string]
    ['part' Manifest_string]
    ['inherit' Class_name_list]
    ['query' Query_list]
    ['command' Command_list]
    ['constraint' Constraint_list]
    'end'
Query_list ::= {Manifest_string "," ...}+
Command_list ::= {Manifest_string "," ...}+
Constraint_list ::= {Manifest_string "," ...}+
Class_name_list ::= {Class_name "," ...}+
Class_name ::= Identifier
--
Event_chart ::= 'event_chart' System_name
    ['incoming' | 'outgoing']
    ['indexing' Index_list]
    ['explanation' Manifest_string]
    ['part' Manifest_string]
    [Event_entries]
    'end'
Event_entries ::= {Event_entry ...}+
Event_entry ::= 'event' Manifest_string 'involves' Class_name_list
--
Scenario_chart ::= 'scenario_chart' System_name
    ['indexing' Index_list]
    ['explanation' Manifest_string]
    ['part' Manifest_string]
    [Scenario_entries]
    'end'
Scenario_entries ::= {Scenario_entry ...}+
Scenario_entry ::= 'scenario' Manifest_string
    'description' Manifest_textblock
--
Creation_chart ::= 'creation_chart' System_name
    ['indexing' Index_list]
    ['explanation' Manifest_string]
    ['part' Manifest_string]
    [Creation_entries]
    'end'
Creation_entries ::= {Creation_entry ...}+
Creation_entry ::= 'creator' Class_name 'creates' Class_name_list

-- STATIC DIAGRAMS
Static_diagram ::= 'static_diagram' [Extended_id] [Comment]
    'component' Static_block 'end'
Extended_id ::= Identifier | Integer
Comment ::= {Line_comment New_line ...}+
Line_comment ::= "--" Simple_string
Static_block ::= {Static_component ...}
Static_component ::= Cluster | Class | Static_relation
--
Cluster ::= 'cluster' Cluster_name
    ['reused'] [Comment]
    [Cluster_components]
Cluster_components ::= 'component' Static_block 'end'
Class ::= ['root' | 'deferred' | 'effective']
    'class' Class_name [Formal_generics]
    ['reused'] ['persistent'] ['interfaced'] [Comment]
    [Class_interface]
Static_relation ::= Inheritance_relation | Client_relation
--
Inheritance_relation ::= Child 'inherit' ["{" Multiplicity "}"]
    Parent [Semantic_label]
Client_relation ::= Client 'client' [Client_entities] [Type_mark]
    Supplier [Semantic_label]
Client_entities ::= "{" Client_entity_expression "}"
Client_entity_expression ::= Client_entity_list | Multiplicity
Client_entity_list ::= {Client_entity "," ...}+
Client_entity ::= Feature_name | Supplier_indirection |
    Parent_indirection
Supplier_indirection ::= [Indirection_feature_part ":"] Generic_indirection
Indirection_feature_part ::= Feature_name | Indirection_feature_list
Indirection_feature_list ::= "(" Feature_name_list ")"
Parent_indirection ::= "->" Generic_indirection
--
Generic_indirection ::= Formal_generic_name | Named_indirection
Named_indirection ::= Class_name "[" Indirection_list "]"
Indirection_list ::= {Indirection_element "," ...}+
Indirection_element ::= "..." | Named_indirection
Type_mark ::= ":" | ":{" | Shared_mark
Shared_mark ::= ":" "(" Multiplicity ")"
--
Child ::= Static_ref
Parent ::= Static_ref
Client ::= Static_ref
Supplier ::= Static_ref
Static_ref ::= {Cluster_prefix ...} Static_component_name
Cluster_prefix ::= Cluster_name "."
Static_component_name ::= Class_name | Cluster_name
Multiplicity ::= Integer
Semantic_label ::= Manifest_string

-- CLASS INTERFACE DESCRIPTION
Class_interface ::= ['indexing' Index_list]
    ['inherit' Parent_class_list]
    Features
    ['invariant' Class_invariant]
    'end'
Class_invariant ::= Assertion
Parent_class_list ::= {Class_type ";" ...}+
Features ::= {Feature_clause ...}+
--
Feature_clause ::= 'feature' [Selective_export]
    [Comment]
    Feature_specifications
Feature_specifications ::= {Feature_specification ...}+
Feature_specification ::= ['deferred' | 'effective' | 'redefined']
    Feature_name_list [Type_mark Type]
    [Rename_clause]
    [Comment]
    [Feature_arguments]
    [Contract_clause]
--
Contract_clause ::= Contracting_conditions 'end'
Contracting_conditions ::= Precondition | Postcondition | Pre_and_post
Precondition ::= 'require' Assertion
Postcondition ::= 'ensure' Assertion
Pre_and_post ::= Precondition Postcondition
--
Selective_export ::= "{" Class_name_list "}"
Feature_name_list ::= {Feature_name "," ...}+
Feature_name ::= Identifier | Prefix | Infix
Rename_clause ::= "{" Renaming "}"
Renaming ::= "^" Class_name "." Feature_name
Feature_arguments ::= {Feature_argument ...}+
Feature_argument ::= "->" [Identifier_list ":"] Type
Identifier_list ::= {Identifier "," ...}+
Prefix ::= 'prefix' '"' Prefix_operator '"'
Infix ::= 'infix' '"' Infix_operator '"'
Prefix_operator ::= Unary | Free_operator
Infix_operator ::= Binary | Free_operator
--
Formal_generics ::= "[" Formal_generic_list "]"
Formal_generic_list ::= {Formal_generic "," ...}+
Formal_generic ::= Formal_generic_name ["->" Class_type]
Formal_generic_name ::= Identifier
Class_type ::= Class_name [Actual_generics]
Actual_generics ::= "[" Type_list "]"
Type_list ::= {Type "," ...}+
Type ::= Class_type | Formal_generic_name
--
Unary ::= 'delta' | 'old' | 'not' | "+" | "-"
Binary ::= "+" | "-" | "*" | "/" |
    "<" | ">" | "<=" | ">=" |
    "\(eq" | "/=" | "/" | "\\" | "^" |
    'or' | 'xor' | 'and' | '"->"' | '"<->"' |
    'member_of' | ":"

-- FORMAL ASSERTIONS
Assertion ::= {Assertion_clause ";" ...}+
Assertion_clause ::= Boolean_expression | Comment
Boolean_expression ::= Expression
Expression ::= Quantification | Call |
    Operator_expression | Constant
Quantification ::= Quantifier Range_expression
    [Restriction] Proposition
Quantifier ::= 'for_all' | 'exists'
Range_expression ::= {Variable_range ";" ...}+
Restriction ::= 'such_that' Boolean_expression
Proposition ::= 'it_holds' Boolean_expression
Variable_range ::= Member_range | Type_range
Member_range ::= Identifier_list 'member_of' Set_expression
Type_range ::= Identifier_list ":" Type
--
Call ::= [Parenthesized_qualifier] Call_chain
Parenthesized_qualifier ::= Parenthesized "."
Call_chain ::= {Unqualified_call "." ...}+
Unqualified_call ::= Identifier [Actual_arguments]
Actual_arguments ::= "(" Expression_list ")"
Expression_list ::= {Expression "," ...}+
Operator_expression ::= Parenthesized | Unary_expression | Binary_expression
Parenthesized ::= "(" Expression ")"
--
Unary_expression ::= Prefix_operator Expression
Binary_expression ::= Expression Infix_operator Expression
Set_expression ::= Enumerated_set | Call | Operator_expression
Enumerated_set ::= "{" Enumeration_list "}"
Enumeration_list ::= {Enumeration_element "," ...}+
Enumeration_element ::= Expression | Interval
Interval ::= Integer_interval | Character_interval
Integer_interval ::= Integer_constant ".." Integer_constant
Character_interval ::= Character_constant ".." Character_constant
--
Constant ::= Manifest_constant | 'Current' | 'Void'
Manifest_constant ::= Boolean_constant | Character_constant |
    Integer_constant | Real_constant |
´     Manifest_string
Sign ::= "+" | "-"
Boolean_constant ::= 'true' | 'false'
Character_constant ::= "'" Character "'"
Integer_constant ::= [Sign] Integer
Real_constant ::= [Sign] Real
Manifest_textblock ::= String_begin String String_end
String ::= {Simple_string New_line ...}+
Manifest_string ::= String_begin Simple_string String_end
--
--DYNAMIC DIAGRAMS
Dynamic_diagram ::= 'dynamic_diagram' [Extended_id] [Comment]
    'component' Dynamic_block 'end'
Dynamic_block ::= {Dynamic_component ...}
Dynamic_component ::= Scenario_description |
    Object_group |
    Object_stack |
    Object |
    Message_relation
--
Scenario_description ::= 'scenario' Scenario_name [Comment]
    'action' Labeled_actions 'end'
Labeled_actions ::= {Labeled_action ...}+
Labeled_action ::= Action_label Action_description
Action_label ::= Manifest_string
Action_description ::= Manifest_textblock
Scenario_name ::= Manifest_string
--
Object_group ::= ['nameless'] 'object_group' Group_name [Comment]
    [Group_components]
Group_components ::= 'component' Dynamic_block 'end'
Object_stack ::= 'object_stack' Object_name [Comment]
Object ::= 'object' Object_name [Comment]
--
Message_relation ::= Caller 'calls' Receiver [Message_label]
Caller ::= Dynamic_ref
Receiver ::= Dynamic_ref
Dynamic_ref ::= {Group_prefix ...} Dynamic_component_name
Group_prefix ::= Group_name "."
Dynamic_component_name ::= Object_name | Group_name
Object_nam ::= Class_name ["." Extended_id]
Group_name ::= Extended_id
Message_label ::= Manifest_string

-- NOTAIONAL TUNING
Notational_tuning ::= Change_string_marks |
    Change_concatenator |
    Change_prefix
Change_string_marks ::= 'string_marks' Manifest_string Manifest_string
Change_concatenator ::= 'concatenator' Manifest_string
Change_prefix ::= 'keyword_prefix' Manifest_string