Monthly Archives: April 2019

artificial intelligence, Artificial Intelligence (AI), aufmented intelligence, bottom-up, cognition, cognitive processes, collective intelligence, communication, continuous learning, creativity, Engineering, Epistemology, HCI history, HMI, HMI history, Human-Machine Interaction, innovation, intelligence, interaction, interface, intuition, learning, machine learning, Philosophy, Philosophy of Science, Philosophy of the actor, preferences, society, top-down, true, truth

THE BIG PICTURE: HCI – HMI – AAI in History – Engineering – Society – Philosophy

eJournal: uffmm.org,
ISSN 2567-6458, 20.April 2019
Email: info@uffmm.org
Author: Gerd Doeben-Henisch
Email: gerd@doeben-henisch.de

A first draft version …

CONTEXT

The context for this text is the whole block dedicated to the AAI (Actor-Actor Interaction)  paradigm. The aim of this text is to give the big picture of all dimensions and components of this subject as it shows up during April 2019.

The first dimension introduced is the historical dimension, because this allows a first orientation in the course of events which lead  to the actual situation. It starts with the early days of real computers in the thirties and forties of the 20 century.

The second dimension is the engineering dimension which describes the special view within which we are looking onto the overall topic of interactions between human persons and computers (or machines or technology or society). We are interested how to transform a given problem into a valuable solution in a methodological sound way called engineering.

The third dimension is the whole of society because engineering happens always as some process within a society.  Society provides the resources which can be used and spends the preferences (values) what is understood as ‘valuable’, as ‘good’.

The fourth dimension is Philosophy as that kind of thinking which takes everything into account which can be thought and within thinking Philosophy clarifies conditions of thinking, possible tools of thinking and has to clarify when some symbolic expression becomes true.

HISTORY

In history we are looking back in the course of events. And this looking back is in a first step guided by the  concepts of HCI (Human-Computer Interface) and  HMI (Human-Machine Interaction).

It is an interesting phenomenon how the original focus of the interface between human persons and the early computers shifted to  the more general picture of interaction because the computer as machine developed rapidly on account of the rapid development of the enabling hardware (HW)  the enabling software (SW).

Within the general framework of hardware and software the so-called artificial intelligence (AI) developed first as a sub-topic on its own. Since the last 10 – 20 years it became in a way productive that it now  seems to become a normal part of every kind of software. Software and smart software seem to be   interchangeable. Thus the  new wording of augmented or collective intelligence is emerging intending to bridge the possible gap between humans with their human intelligence and machine intelligence. There is some motivation from the side of society not to allow the impression that the smart (intelligent) machines will replace some day the humans. Instead one is propagating the vision of a new collective shape of intelligence where human and machine intelligence allows a symbiosis where each side gives hist best and receives a maximum in a win-win situation.

What is revealing about the actual situation is the fact that the mainstream is always talking about intelligence but not seriously about learning! Intelligence is by its roots a static concept representing some capabilities at a certain point of time, while learning is the more general dynamic concept that a system can change its behavior depending from actual external stimuli as well as internal states. And such a change includes real changes of some of its internal states. Intelligence does not communicate this dynamics! The most demanding aspect of learning is the need for preferences. Without preferences learning is impossible. Today machine learning is a very weak example of learning because the question of preferences is not a real topic there. One assumes that some reward is available, but one does not really investigate this topic. The rare research trying to do this job is stating that there is not the faintest idea around how a general continuous learning could happen. Human society is of no help for this problem while human societies have a clash of many, often opposite, values, and they have no commonly accepted view how to improve this situation.

ENGINEERING

Engineering is the art and the science to transform a given problem into a valuable and working solution. What is valuable decides the surrounding enabling society and this judgment can change during the course of time.  Whether some solution is judged to be working can change during the course of time too but the criteria used for this judgment are more stable because of their adherence to concrete capabilities of technical solutions.

While engineering was and is  always  a kind of an art and needs such aspects like creativity, innovation, intuition etc. it is also and as far as possible a procedure driven by defined methods how to do things, and these methods are as far as possible backed up by scientific theories. The real engineer therefore synthesizes art, technology and science in a unique way which can not completely be learned in the schools.

In the past as well as in the present engineering has to happen in teams of many, often many thousands or even more, people which coordinate their brains by communication which enables in the individual brains some kind of understanding, of emerging world pictures,  which in turn guide the perception, the decisions, and the concrete behavior of everybody. And these cognitive processes are embedded — in every individual team member — in mixtures of desires, emotions, as well as motivations, which can support the cognitive processes or obstruct them. Therefore an optimal result can only be reached if the communication serves all necessary cognitive processes and the interactions between the team members enable the necessary constructive desires, emotions, and motivations.

If an engineering process is done by a small group of dedicated experts  — usually triggered by the given problem of an individual stakeholder — this can work well for many situations. It has the flavor of a so-called top-down approach. If the engineering deals with states of affairs where different kinds of people, citizens of some town etc. are affected by the results of such a process, the restriction to  a small group of experts  can become highly counterproductive. In those cases of a widespread interest it seems promising to include representatives of all the involved persons into the executing team to recognize their experiences and their kinds of preferences. This has to be done in a way which is understandable and appreciative, showing esteem for the others. This manner of extending the team of usual experts by situative experts can be termed bottom-up approach. In this usage of the term bottom-up this is not the opposite to top-down but  is reflecting the extend in which members of a society are included insofar they are affected by the results of a process.

SOCIETY

Societies in the past and the present occur in a great variety of value systems, organizational structures, systems of power etc.  Engineering processes within a society  are depending completely on the available resources of a society and of its value systems.

The population dynamics, the needs and wishes of the people, the real territories, the climate, housing, traffic, and many different things are constantly producing demands to be solved if life shall be able and continue during the course of time.

The self-understanding and the self-management of societies is crucial for their ability to used engineering to improve life. This deserves communication and education to a sufficient extend, appropriate public rules of management, otherwise the necessary understanding and the freedom to act is lacking to use engineering  in the right way.

PHILOSOPHY

Without communication no common constructive process can happen. Communication happens according to many  implicit rules compressed in the formula who when can speak how about what with whom etc. Communication enables cognitive processes of for instance  understanding, explanations, lines of arguments.  Especially important for survival is the ability to make true descriptions and the ability to decide whether a statement is true or not. Without this basic ability communication will break down, coordination will break down, life will break down.

The basic discipline to clarify the rules and conditions of true communication, of cognition in general, is called Philosophy. All the more modern empirical disciplines are specializations of the general scope of Philosophy and it is Philosophy which integrates all the special disciplines in one, coherent framework (this is the ideal; actually we are far from this ideal).

Thus to describe the process of engineering driven by different kinds of actors which are coordinating themselves by communication is primarily the task of philosophy with all their sub-disciplines.

Thus some of the topics of Philosophy are language, text, theory, verification of a  theory, functions within theories as algorithms, computation in general, inferences of true statements from given theories, and the like.

In this text I apply Philosophy as far as necessary. Especially I am introducing a new process model extending the classical systems engineering approach by including the driving actors explicitly in the formal representation of the process. Learning machines are included as standard tools to improve human thinking and communication. You can name this Augmented Social Learning Systems (ASLS). Compared to the wording Augmented Intelligence (AI) (as used for instance by the IBM marketing) the ASLS concept stresses that the primary point of reference are the biological systems which created and create machine intelligence as a new tool to enhance biological intelligence as part of biological learning systems. Compared to the wording Collective Intelligence (CI) (as propagated by the MIT, especially by Thomas W.Malone and colleagues) the spirit of the CI concept seems to be   similar, but perhaps only a weak similarity.

python 3, reading a file

Example python3: popShow0 – simple file-reader

eJournal: uffmm.org,
ISSN 2567-6458, 6.April 2019
Email: info@uffmm.org
Author: Gerd Doeben-Henisch
Email: gerd@doeben-henisch.de

CONTEXT

This is a possible 5th step in the overall topic ‘Co-Learning python3′. After downloading WinPython and activating the integrated editor ‘spyder’ (see here),  one can edit another simple program dealing with population dynamics in a most simple way (see the source code below under the title ‘EXAMPLE: popShow0.py’). This program is a continuation of the program pop0e.py, which has been described here.

COMMENTS

In this post I comment only on the changes between the actual program and the version before.

IMPORT

In this program the following two libraries are used:

import numpy as np # Lib for math
from tkinter.filedialog import askopenfilename

numpy is known from previous programs while tkinter is here used to enable a file dialog to find a certain file while browing the different folders.

The program opens such a windows for browsing:

print(‘A window is asking you for a filename\n’)
infilename = askopenfilename()

The variable ‘infilename’ is a variable for strings, which in this case saves the content of the file.  This content looks like this:

# br=0.03,dr=0.019
# X-Column, Y-Column
1.000000000000000000e+00   7.466964000000000000e+06
2.000000000000000000e+00   7.549100604000000283e+06
3.000000000000000000e+00   7.632140710644000210e+06
4.000000000000000000e+00   7.716094258461084217e+06
5.000000000000000000e+00   7.800971295304155909e+06
6.000000000000000000e+00   7.886781979552501813e+06
7.000000000000000000e+00   7.973536581327578984e+06
8.000000000000000000e+00   8.061245483722181991e+06
9.000000000000000000e+00   8.149919184043126181e+06
1.000000000000000000e+01    8.239568295067600906e+06
1.100000000000000000e+01    8.330203546313344501e+06
1.200000000000000000e+01    8.421835785322790965e+06
1.300000000000000000e+01    8.514475978961341083e+06
1.400000000000000000e+01    8.608135214729916304e+06
1.500000000000000000e+01    8.702824702091945335e+06
1.600000000000000000e+01    8.798555773814957589e+06

This context will then be formatted by the following lines:

data = np.loadtxt(infilename)
x = data[:, 0]
y = data[:, 1]

The leading header will automatically be discarded and the main content will be stored in two columns. These formatted two-columns data will then be printed with:

for i in range(len(x)):
print(‘Year %d = Citizens. %9.0f \n’ % (x[i],y[i]))

For each of the values to print x[i] and y[i] there are formatting options telling that the x[i] represents a ‘year’ understood as an integer, and  that y[i] represents the population number Citizens understood as a floting point number with zero signs behind the floating point.

The output looks then like this (Date are from the UN for 2016; the simulation computes this into a possible future):

Year 1 = Citizens. 7466964

Year 2 = Citizens. 7549101

Year 3 = Citizens. 7632141

Year 4 = Citizens. 7716094

Year 5 = Citizens. 7800971

Year 6 = Citizens. 7886782

Year 7 = Citizens. 7973537

Year 8 = Citizens. 8061245

Year 9 = Citizens. 8149919

Year 10 = Citizens. 8239568

Year 11 = Citizens. 8330204

Year 12 = Citizens. 8421836

Year 13 = Citizens. 8514476

Year 14 = Citizens. 8608135

Year 15 = Citizens. 8702825

Year 16 = Citizens. 8798556

What is missing here is the information about the ‘real years’ as 1 = 2016 etc.

SOURCE CODE for popShow0.py

popShow0.py as popShow0.pdf

data in a file, python 3

Example python3: pop0e – simple population program

eJournal: uffmm.org,
ISSN 2567-6458, 4-6.April 2019
Email: info@uffmm.org
Author: Gerd Doeben-Henisch
Email: gerd@doeben-henisch.de

CONTEXT

This is a possible 4th step in the overall topic ‘Co-Learning python3′. After downloading WinPython and activating the integrated editor ‘spyder’ (see here),  one can edit another simple program dealing with population dynamics in a most simple way (see the source code below under the title ‘EXAMPLE: pop0e.py’). This program is a continuation of the program pop0d.py, which has been described here.

COMMENTS

In this post I comment only on the changes between the actual program and the version before.

IMPORTS

In the new version one more liibrary is used for the handling of time stamps:

import time # Lib for time

STORING DATA IN A FILE

The only extension in the new version of the small program are some lines enabling the storage of the data from the simulation in a file.

data = np.column_stack((x,pop))

This line is formating the plot-values as x and x axes written as two columns bedides each other in a file.

What comes next is a construction of a file name which includes the actual time as well as the values of the br and the dr variable:

ts = time.gmtime()
t=time.strftime(“%c”, ts) # format time data into ISO format
t=t.replace(‘ ‘,’-‘)
t=t.replace(‘:’,’-‘)
header=’br=’+str(br)+’,’+’dr=’+str(dr)+’\n’+’X-Column, Y-Column’
fname=’hxyPTL’+t+’br=’+str(br)+’-‘+’dr=’+str(dr)

After this construction a file is generated with the plotting data as well as an expressive name.

np.savetxt(fname+’.txt’, data,header=header)

SOURCE CODE

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
“””
Created on Thu 4-6 April Konga (Sweden) 2019

@author: gerd doeben-henisch
Email: gerd@doeben-henisch.de
“””

##################################
# pop0e()
###################################
#
# IDEA
#
# Simple program to compute the increase/ decrease of a population with
# the parameters population number (p), birth-rate (br) and death-rate (dr).
# In this version an extension with the following features:
# – a loop to repeat the computation for n-many cycles
# – a storage of the data in an array
# – an additional automatic storage of the plotting data in a file
# with the actual time in the file-name
# – a plot of the stored data for n-many cycles
# – the overall change of the population in %

#########################################################
# IMPORTS
# As part of the distribution of Winpython there are already many
# libraries pre-installed, which can be activated by the import command.
# Other libraries outside of the distribution have to be downloaded
# with the pip command
# Lib for plotting

import matplotlib.pyplot as plt # Lib for plotting
import numpy as np # Lib for math
import time # Lib for time

###########################################################
# DEFINITION

def pop0(p,br,dr):

p=p+(p*br)-(p*dr)

return p

###################################
# INPUT OF DATA

p = int(input(‘Population number ? ‘))

br = float(input(‘Birthrate in % ? ‘))
br = br/100

dr = float(input(‘Deathrate in % ? ‘))
dr = dr/100

n = int(input(‘How many cycles ? ‘))

baseYear = int(input(‘What is your Base Year ? ‘))

#############################################
# GLOBAL VARIABLES

pop = [] # storage for the pop-numbers for plotting
pop.append(p)

#################################################
# COMPUTE

for i in range(n):
p=pop0(p,br,dr)
pop.append(p)

##################################################
# SHOW RESULTS

for i in range(n+1):
print(‘Year %5d = Citizens. %8d \n’ %(baseYear+i, pop[i]) )

x = np.linspace(1,len(pop),len(pop))

plt.plot(x, pop, ‘bo’)
plt.show()

#####################################################
# STORE VALUES ON DISK
#
# For this see the online article
# https://www.pythonforthelab.com/blog/introduction-to-storing-data-in-files/
#
# Saves the plot data automatically in a file with a header and two columns

data = np.column_stack((x,pop))
ts = time.gmtime()
t=time.strftime(“%c”, ts) # format time data into ISO format
t=t.replace(‘ ‘,’-‘)
t=t.replace(‘:’,’-‘)
header=’br=’+str(br)+’,’+’dr=’+str(dr)+’\n’+’X-Column, Y-Column’
fname=’hxyPTL’+t+’br=’+str(br)+’-‘+’dr=’+str(dr)
np.savetxt(fname+’.txt’, data,header=header)

###########################################
# Compute Change of POP

n1=pop[0]
n2=pop[len(pop)-1]
Increase=(n2-n1)/(n1/100)

print(“From Year %5d, until Year %5d, a change of %2.2f percent \n” % (baseYear, baseYear+n,Increase) )

plt.close()

####################################################
# REAL DATA
#
# UN Demographic Yearbook 2017
# https://unstats.un.org/unsd/demographic-social/products/dyb/dybsets/2017.pdf
#
# Basic Tables UN
# https://unstats.un.org/unsd/demographic-social/products/vitstats/seratab1.pdf
#
# UN public tables
# http://data.un.org/Explorer.aspx?d=POP
#
# UN Rate of population change
# http://data.un.org/Data.aspx?d=PopDiv&f=variableID%3a47
# https://www.un.org/en/development/desa/population/index.asp
”’
Population number ? 6958169

Birthrate in % ? 1.9

Deathrate in % ? 0.77

How many cycles ? 15

What is your Base Year ? 2010
Year 2010 = Citizens. 6958169

Year 2011 = Citizens. 7036796

Year 2012 = Citizens. 7116312

Year 2013 = Citizens. 7196726

Year 2014 = Citizens. 7278049

Year 2015 = Citizens. 7360291

Year 2016 = Citizens. 7443462

Year 2017 = Citizens. 7527573

Year 2018 = Citizens. 7612635

Year 2019 = Citizens. 7698658

Year 2020 = Citizens. 7785653

Year 2021 = Citizens. 7873630

Year 2022 = Citizens. 7962602

Year 2023 = Citizens. 8052580

Year 2024 = Citizens. 8143574

Year 2025 = Citizens. 8235596

From Year 2010, until Year 2025, a change of 18.36 percent

Real UN data for 2010 – 2015
2010 2011 2012 2013 2014 2015
6 958 169 7 043 009 7 128 177 7 213 426 7 298 453 7.383.009

########################################################
# STORING DATA
#
# https://www.pythonforthelab.com/blog/introduction-to-storing-data-in-files/
#
# Example of saved file:
file name:
hxyPTLSun-Apr–7-08-55-46-2019br=0.019-dr=0.0077.txt

# br=0.019,dr=0.0077
# X-Column, Y-Column
1.000000000000000000e+00 6.958169000000000000e+06
2.000000000000000000e+00 7.036796309700000100e+06
3.000000000000000000e+00 7.116312107999609783e+06
4.000000000000000000e+00 7.196726434820005670e+06
5.000000000000000000e+00 7.278049443533471785e+06
6.000000000000000000e+00 7.360291402245399542e+06
7.000000000000000000e+00 7.443462695090772584e+06
8.000000000000000000e+00 7.527573823545298539e+06
9.000000000000000000e+00 7.612635407751359977e+06
1.000000000000000000e+01 7.698658187858950347e+06
1.100000000000000000e+01 7.785653025381756946e+06
1.200000000000000000e+01 7.873630904568570666e+06
1.300000000000000000e+01 7.962602933790194802e+06
1.400000000000000000e+01 8.052580346942024305e+06
1.500000000000000000e+01 8.143574504862469621e+06
1.600000000000000000e+01 8.235596896767416038e+06
”’

 

 

python 3

Example python3: pop0d – simple population program

eJournal: uffmm.org,
ISSN 2567-6458, 2-4.April 2019
Email: info@uffmm.org
Author: Gerd Doeben-Henisch
Email: gerd@doeben-henisch.de

CONTEXT

This is a possible 3rd step in the overall topic ‘Co-Learning python3′. After downloading WinPython and activating the integrated editor ‘spyder’ (see here),  one can edit another simple program dealing with population dynamics in a most simple way (see the source code below under the title ‘EXAMPLE: pop0d.py’). This program is a continuation of the program pop0.py, which has been described here.

COMMENTS

In this post I comment only on the changes between the actual program and the version before.

IMPORTS

In the new version two libraries are used:

import matplotlib.pyplot as plt # Lib for plotting
import numpy as np # Lib for math

This extends the set of possible functions by functions for plotting and some more math.

MORE INPUT DATA

In this version one can enter a base year, thus allowing a direct relation to real year numbers in the history or the future. In the example run at the end of the program I am using the official population numbers of the UN for the world population in the years 2016 and 2017, which will hypothetically be forecasted for 15 years.

MORE GLOBAL VARIABLES

As explained in the previous version there are local variables restricted in their meaning to a certain function and global variables outside a function. In this version a datastructure called pop is introduced to store information in a sequential order. In this case the first population number given in the variable p is stored on the first position by the append operation which is part of the data structure pop.

pop = [] # storage for the pop-numbers for plotting
pop.append(p)

Later a data structure x is needed  a s a sequence of consecutive numbers starting with 1, ending with the number of entries in the pop data strucure and with as many positions as pop has entries. The number of elements in pop can be computed by applying the len() operator to pop.

x = np.linspace(1,len(pop),len(pop))

EXTENDED COMPUTATION

The computation has extended a little bit by the new line appending the actual value of p to the pop storage:

for i in range(n):
       p=pop0(p,br,dr)
      pop.append(p)

Thus the pop data structure stores every new population value in p in the sequential order of its occurence. Moreover it has been here realized a loop with the for function. The variable i is running through a sequence of values provided by the range() function. This function builts an array of numbers from 0 to n-1 and repeats therefor the call of pop0() n times.

But the most important point here is that the value of the global variable p is handed over to the function pop0(), and the local value of the variable p inside the pop0() function is again handed over by the return command to the outside of the function. Outside there is waiting the global p variable which is receiving the new value by the =-operation. In the next call of pop0() pop0() receives as new input the global variable p with the new value.

SHOWING THE RESULTS

There are now three different data show actions: (i) the list of all years with their numbers, (ii) a graphical plot of data points, and (iii) a print out of the increase of the population compared the final result with the base year.

LIST OF ALL YEARS

for i in range(n+1):
print(‘Year %5d = Citizens. %8d \n’ %(baseYear+i, pop[i]) )

Again is the for function in action ranging through the number of cycles given by the variable n. The number of the population in the different years is catched from the pop data structure by indexing the individual elements of pop by the bracket command []. pop[i] represents the i-th element of pop.

PLOTING THE POPULATION VALUES

x = np.linspace(1,len(pop),len(pop))
plt.plot(x, pop, ‘bo’)
plt.show()

The plotfunction plot of the library plt needs an arry of numbers for the x-axis given here by the x data structure, an arry of numbers for the y-axis given here by the pop-data structures, and optionally some parameter for the format of the plot symbolds. Here with ‘bo’ a black small circle. After all values are prepared will the command plt.show() make the plotted data visible.

Plot with the UN data for the possible growth of the world population
Plot with the UN data for the possible growth of the world population

OVERALL PERCENTAGE OF CHANGE

n1=pop[0]
n2=pop[len(pop)-1]
Increase=(n2-n1)/(n1/100)

print(“From Year %5d, until Year %5d, a change of %2.2f percent \n” % (baseYear, baseYear+n,Increase) )

Getting the base year from pop[0] and the last year from pop[len(pop)-1] one can compute the difference as the increase translated into a percentage.

REAL DATA

Although the population program is still very simple it is usefull to compute real numbers of the real world. One example are the official data of the United Nations (UN) which are collecting world wide data since their foundation 1948.

But, as a first surprise, although the UN provides lots of data from all the countries world wide, they do not systematicall a birthrate (br) or a deathrate (dr). Thus I have compiled the br and dr by inferring it from absolute population numbers from 2016 and 2017 combined with the fertility rate for 1000 people in the year 2013 averaged over all countries. This gives an estimate of 3% for the birthrate br. Using this from 2016 to 2017 this gives an ‘overshoot’ to the real numbers of 2017. I inferred from this the deathrate dr which is clearly a very week inference. Nevertheless it works for 2016 to 2017 and gives a first simple example for the upcoming years.

SOURCE CODE OF pop0d.py

pop0d.py as pop0d.pdf

function, function call, function definition, function-body, function-call, global variable, input function, local variable, output function, python 3, variable, variable

Example python3: pop0 – simple population program

eJournal: uffmm.org,
ISSN 2567-6458, 2-3.April 2019
Email: info@uffmm.org
Author: Gerd Doeben-Henisch
Email: gerd@doeben-henisch.de

CONTEXT

This is a possible 2nd step in the overall topic ‘Co-Learning python3′. After downloading WinPython and activating the integrated editor ‘spyder’ (see here),  one can edit a first simple program dealing with population dynamics in a most simple way (see the source code below under the title ‘EXAMPLE: pop0.py’.

BASIC PROGRAMMING ELEMENTS

SOURCE FILE

The source code is stored under the name ‘pop0.py’. It is a ‘stand alone’ program not making use of any kind of a library except the built in functions of python3. The external libraries can be included by the ‘import command’.

FUNCTION DEFINITION

If one wants to use the built-in functions in some new way one can do this by telling the computer the keyword ‘def‘ which states that the following text defines a new function.

A function has always a name, some input arguments between rounded brackets followed by a colon marking the beginning of the function-body.  After the colon follows a list of built-in commands or some already defined functions. With defined functions one can make life much easier. Instead of repeating all the commands of the function-body again and again one can limit the writing to the call of the function name with its input arguments.

In the example file we have the following function definition:

def pop0(p,br,dr):
       p=p+(p*br)-(p*dr)
       return p

The name is pop0, the input arguments are (p,br,dr), the used built-in functions are +, -, *, return as well as the =-sign, and the new composition is p=p+(p*br)-(p*dr). This new composition combines known function names with new variable names to compute a certain mathematical mapping. The result of this simple mapping is stored in the variable ‘p’ and it is delivered to the outside of the function pop0 by the return-statement.

NECESSARY INPUT VALUES

To run the program one has to call the defined new function. But because the called function will need some values for the input variables one has first to enable the user to interact with the program by some input commands.

The input commands are informing the user which kind of information is asked for and the answers of the users will be stored in the variables p, br, and dr. The input values can also be ‘casted‘ into different value types like int — for integer — and float — for floating point –.

Here is the protocol of a possible input:

Number of citizens in the start year? 1000

Birthrate %? 0.82

Deathrate in %? 0.92

CALLING A DEFINED FUNCTION

After these preparations one can call the defined new function with the statement pnew = pop0(p,br,dr). Because the input variables have values received from the user the new function can start it’s mapping and can compute the follow up value for the population.

SHOW RESULTS

To show the user this new value explicitly on the screen  one has to use the print function, the counterpart to the input function:  print(‘New population number:\n’,int(pnew)). The print function prints the new value for the population number on the screen.  If you look closer to the print function you can detect some inherent structure: print() is the main structure with the function name ‘print’ and the brackets () as the placeholder for possible input arguments. In the used example the input arguments have two ‘parts’: (‘…’,v). The ‘…’-part allows some text which will be shown to the user, in our case New population number: followed by a line break caused by the symbols \n. The v-part allows the names of variables which have some values which can be printed. In the used example we have the expression int(pnew). pnew is the name of a variable with a value delivered by the pop0() function enabled by the return p function of the pop0() function. (Attention: the ‘return’ function works without ()-brackets to receive input arguments! The variable ‘p’ is an input argument) The value delivered by ‘return p’ is a floating point value. But because we have only ‘whole citizens’ we cast the non-integer parts of the float value away by making the variable ‘pnew’ an argument of another function int(). The int() function translates a floating point value into an integer value. This is the reason that we do not see ‘999.0’ but ‘999’:

New population number:
999

REMARK: Global and Local Variables

This simple example tells already something about the difference between global and local values. If one enters the variable names ‘p’ and ‘pnew’ in the python console of the spyder editor then one can see the following:

p
Out[5]: 1000

pnew
Out[6]: 999.0

After the function call to pop0() the original value of ‘p’ is unchanged, and the new value ‘pnew’ is different. That means the new value of ‘p internal in the function’ and the ‘old value of p external to the function’ are separated. The name of a variable has therefore to be distinguished with regard to the actual context: The same name  in different contexts (inside a function definition or outside) does represents different memory spaces.   The variable names inside a function definition are called local variables and the variable names external to a function definition are called global variables.

A continuation of this post you can find here.

SOURCE CODE: EXAMPLE: pop0.py

pop0.py as pop0.pdf

co-learning, programming, Programming Language, python 3

Co-Learning with python 3

 

eJournal: uffmm.org, ISSN 2567-6458,
First: April 1, 2019
Last: October 21, 2020
Email: info@uffmm.org
Author: Gerd Doeben-Henisch
Email: gerd@doeben-henisch.de

CONTEXT

This python programming section is part of the uffmm science blog..

OBJECTIVE

The context of this small initiative ist the Distributed-Actor-Actor Interaction (DAAI) paradigm described in this blog.  For this AAI paradigm one will need an assisting software to manage real problems with real people. In principle this software can be realized by every kind of programming language. Which one will be used for the planned overall software service will be decided by those groups, which will do the final job. But for the development of the ideas, for an open learning process, we will use here the programming language python 3. To get a first understanding of the main programming languages and the special advantages and disadvantages of python 3 compared to python 2 and to other important languages see the short overview here 2019-03-18 in apenwarr or chapters 1-2 from the excellent book by Lutz mentioned below.

VISION

There are many gifted young people around who could produce wonderfull programms, if they would find a ‘start’, how to begin, where to go from here… sometimes these are friends doing other things together — like playing computer games 🙂 — why not start doing programming real programs by themselves? Why not start together some exciting project by their own?

If they want to do it, they need some first steps to enter the scene. This is the idea behind this vision: getting young people to do first steps, helping each other, document the process, improve, making nice things…

CONTRIBUTING POSTS

Here is a list of posts which can support the Co-Learning Process.

The Komega SW-Project

See for details the ‘Case Studies Section‘ of this blog.

The most recent post is on top.

GENERAL REMARK

This code is completely experimental! The only intention is to show how  the ideas of the theory  are working, because for most people the theory is too complex to be easily understood. That’s normal life: as complexity and innovation is raising the understanding is going down …

New Series, from scratch

(The most recent post is on top)

    • STARTING WITH PYTHON3 – The very beginning – part10: Using the git system: For the further development of our first demo we have started a simple server with a git system. All the upcoming work will use this. Attention: the server ha changed! Look for a new presence in a few weeks under the address epolitics4you.org (Last change June-21, 2020)
    • STARTING WITH PYTHON3 – The very beginning – part 9: In part 9 the concept of a simple virtual world has been re-analyzed with the conceptual framework of the AI paradigm thereby enabling a first encounter of the AAI paradigm with the python programming language. It is a complete, working program, nevertheless still simple. In the next posts this will be further extended.
    • STARTING WITH PYTHON3 – The very beginning – part 8: In part 8 the world cycle is started. In this post it is described how one can manage the energy level of all important objects. In case of the actors these will be removed from the grid and from the actor list when they reach energy level <1. Thus, there is real death in this simple world. To survive you must be able to survive. This points to the mystery of life in this universe…
    • STARTING WITH PYTHON3 – The very beginning – part 7: Continuation of editing the 2D virtual world as a grid. A major improvement is the automatic collection of all objects according to their types from the grid as well as the automatic association with individual object values including an individual ID. Thus with only one line one can manage the layout of a whole world filled with individual objects and actors… you will see.
    • STARTING WITH PYTHON3 – The very beginning – part 6: Editing a 2-dimensional virtual world in a grid format for further experiments. Yes, from this post onward I start to develop a complete virtual world (2D) with actors having an increasing amount of artificial intelligence (AI) built in, not only machine learning (ML), but also more and more a cognitive architecture (CA) enabling real semiotic machines (SM).
    • STARTING WITH PYTHON3 – The very beginning – part 5: More strings, sequences, control-statements exemplified with a simple input-output actor which shows some creativity… and some glimpse of cognitive entropy.
    • STARTING WITH PYTHON3 – The very beginning – part 4: Introducing strings and some operations with them. The examples are embedded in a small python program simulating a simple input-output actor which is completely deterministic.
    • STATING WITH PYTHON3 – The very beginning – part 3: Introducing first data types and operations with them. From this post onwards I am using only the windows powershell, an ordinary editor (notepad or notepad++), and python activated from the windows powershell. This is all you need :-). By the way: transferring the used files to Linux — I am using the distribution ubuntu 18.04 LTS — you can work directly without any changes. Instead of the windows powershell you have in Linux your standard systems terminal, calling python you can distinguish between ‘python’ (2.7) ‘python 3’ (3.6), and there are many good editors (I am using jPad, but there are many more). That’s it. Thus you can switch between Linux and windows 10 without any problems.
    • STARTING WITH PYTHON3 – The very beginning – part 2: Continuing with the additional option to use the IDLE tool. … and some more little things.
    • STARTING WITH PYTHON3 – The very beginning – part 1-V2 : This post is a re-writing of the first version for the introductory part to the windows 10 environment. The python coding examples have not been changed. The first version STARTING WITH PYTHON 3 – The very beginning:  is still available.
Older Series, using WinPython with Spyder

More posts will follow in a random order depending of the questions which will arise or the ideas someone wants to test.

REFERENCES

There is a huge amount of python books, articles and online resources. I will mention here only some of the books and resources I have used. The following is therefore neither complete nor closed. I will add occasionally some titles.

  • Mark Lutz, Learn Python, 2013,5th ed.,Sebastopol (CA), O’Reilly
  • Mark Lutz, Programming Python, 2011, 4th ed., Sebastopol (CA), O’Reilly
  • To get the sources: https://www.python.org/
  • Documentation: https://docs.python.org/3/
  • Python Software Foundation (PSF): https://www.python.org/psf-landing/
  • Python Community: https://www.python.org/community/