通常熟悉教材思路模式利於掌握學習進入狀況。故此先講

輸入‧處理‧輸出模型︰

IPO model

The input–process–output (IPO) model, or input-process-output pattern, is a widely used approach in systems analysis and software engineering for describing the structure of an information processing program or other process. Many introductory programming and systems analysis texts introduce this as the most basic structure for describing a process.^[1][2][3][4]

Overview

A computer program or any other sort of process using the input-process-output model receives inputs from a user or other source, does some computations on the inputs, and returns the results of the computations.^[1] In essence the system separates itself from the environment, thus defining both inputs and outputs, as one united mechanism.^[5] The system would divide the work into two categories:

• A requirement from the environment (input)
• A provision for the environment (output)

In other words, such inputs may be materials, human resources, money or information, transformed into outputs, such as consumables, services, new information or money.

As a consequence, Input-Process-Output system becomes very vulnerable to misinterpretation. This is because, theoretically, it contains all the data, in regards to the environment outside the system, yet on practice, environment contains a significant variety of objects, that a system is unable to comprehend, as it exists outside systems control. As a result it is very important, to understand, where the boundary lies, between the system and the environment, which is beyond systems understanding. This is because, often various analysts, would set their own boundaries, favouring their point of view, thus creating much confusion.^[6]

 

指明其與 IPython 之

讀取‧求值‧輸出循環︰

Read–eval–print loop

A Read–Eval–Print Loop (REPL), also known as an interactive toplevel or language shell, is a simple, interactive computer programming environment that takes single user inputs (i.e. single expressions), evaluates them, and returns the result to the user; a program written in a REPL environment is executed piecewise. The term is most usually used to refer to programming interfaces similar to the classic Lisp machine interactive environment. Common examples include command line shells and similar environments for programming languages, and is particularly characteristic of scripting languages.^[1]

Uses

As a shell, a REPL environment allows users to access relevant features of an operating system in addition to providing access to programming capabilities.

The most common use for REPLs outside of operating system shells is for instantaneous prototyping. Other uses include mathematical calculation, creating documents that integrate scientific analysis (e.g. IPython), interactive software maintenance, benchmarking, and algorithm exploration.

A REPL can become an essential part of learning a new language as it gives quick feedback to the novice.

 

密切相關也。這可說是

《Jupyter Audio Basics》文章綱要哩！

─── 《【鼎革‧革鼎】︰ RASPBIAN STRETCH 《六之 J.3‧MIR-3 》》

 

望著

Output widgets: leveraging Jupyter’s display system

 

文本發呆！想著格與格間之互動？隨機而添、而抹的筆意！！

哪裡得『五色筆』

齊光祿江淹

文通詩體總雜，善於摹擬，筋力於王微，成就於謝朓。初，淹罷宣城郡，遂宿冶亭，夢一美丈夫，自稱郭璞，謂淹曰：「我有筆在卿處多年矣，可以見還。」淹探懷中，得五色筆以授之。爾後為詩，不復成語，故世傳江淹才盡。

 

方能寫此璀璨？？

既無下筆處，只好有請讀者

何不『吃茶去』？？？

《趙州禪師語錄 》

（459）師問二新到：「上座曾到此間否？」云：「不曾到。」師云：「吃茶去！」又問那一人：「曾到此間否？」云：「曾到。 」師云：「吃茶去！」院主問：「和尚！不曾到，教伊吃茶去，即且置；曾到，為什麼教伊吃茶去？」師云：「院主。」院主應諾。師云：「吃茶去！」

 

 

 

 

 

 

 

 

《昔時賢文》君子愛財取之有道。

─── 《孔方之阿堵物》

 

生︰今有

ipywidgets/docs/source/examples/

Variable Inspector Widget

 

反背之物怎麼講呢？

師︰遙想

1878 年大發明家愛迪生寫下︰

It has been just so in all of my inventions. The first step is an intuition, and comes with a burst, then difficulties arise — this thing gives out and [it is] then that “Bugs” — as such little faults and difficulties are called — show themselves and months of intense watching, study and labor are requisite before commercial success or failure is certainly reached.

上文中 bugs 是用小昆蟲來指小瑕疵！為什麼呢？不得而知。至於『除蟲』debugging 的由來，就像『黏在繼電器上的飛蛾』一說，也許是故事裡的事，但又何必在意那麼多，相信能有什麼不好呢 ？難道說人不是因夢想而偉大，是一根會思考的蘆葦。這是 1946 的 伊尼亞克 ENIAC 世界上第一台通用型計算機，完全的圖靈機︰

 

為什麼從『錯誤』開始談起呢？對寫程式的人來說，『除錯』是常態。不要害怕『犯錯』，把錯誤看成『敵友』── 唱反調的朋友，它能糾正不清的思慮，改進不明的理解。如果能以『不二過』為圭臬，你將能學的更快更好。

中國古代沒有標點符號，卻有句讀之學，把文本斷句加上圈點，以此確定文意。舉例來說︰

『下雨天留客天天留我不留』這個文本，可以有多種句讀，文意各不相同。

下雨天，留客天；天、留我不留。
下雨，天留客，天天留；我不留。
下雨天，留客；天天留我！不留。

同樣的，人使用電腦，也需要一種清楚的辦法來確定指令（命令 ），一點不能含混不清。技術點的說，人是透過『人機介面』操作電腦。這個『介』或 『界』字一般泛指『兩者之間』的意思，『介面』或譯『界面』interface 一詞在電腦術語的用法上，通常表達物與物的交接處，功能操作的地方。比如說「應用軟體界面 API」指的是電腦程式如何使用軟體系統所提供的「功能程式庫 library」；USB 介面是指電腦主機和 USB 裝置間的硬體介面；而所謂的終端機則提供了人與電腦作業系統的『文字界面』。

─── 摘自《除蟲！除錯？終端機。》

 

幾曾超越『塵歸塵，土歸土』也。既有『蠱』

 蠱卦 (山風蠱)

蠱，元亨，利涉大川。先甲三日，後甲三日。初六，幹父之蠱，有子，考无咎，厲終吉。九二，幹母之蠱，不可貞。九三，幹父之蠱，小有悔，无大咎。六四，裕父之蠱，往見吝。六五，幹父之蠱，用譽。上九，不事王侯，高尚其事。

 

『蟲』自生矣！焉用問？餘者，且是『除不除』哩？！

中不中用，但看學生呦！？

events.py

"""Infrastructure for registering and firing callbacks on application events.
Unlike :mod:`IPython.core.hooks`, which lets end users set single functions to
be called at specific times, or a collection of alternative methods to try,
callbacks are designed to be used by extension authors. A number of callbacks
can be registered for the same event without needing to be aware of one another.
The functions defined in this module are no-ops indicating the names of available
events and the arguments which will be passed to them.
.. note::
   This API is experimental in IPython 2.0, and may be revised in future versions.
"""

from backcall import callback_prototype

……

    def register(self, event, function):
        """Register a new event callback.
        
        Parameters
        ----------
        event : str
          The event for which to register this callback.
        function : callable
          A function to be called on the given event. It should take the same
          parameters as the appropriate callback prototype.
        
        Raises
        ------
        TypeError
          If ``function`` is not callable.
        KeyError
          If ``event`` is not one of the known events.
        """
        if not callable(function):
            raise TypeError('Need a callable, got %r' % function)
        callback_proto = available_events.get(event)
        self.callbacks[event].append(callback_proto.adapt(function))
    
    def unregister(self, event, function):
        """Remove a callback from the given event."""
        if function in self.callbacks[event]:
            return self.callbacks[event].remove(function)

        # Remove callback in case ``function`` was adapted by `backcall`.
        for callback in self.callbacks[event]:
            try:
                if callback.__wrapped__ is function:
                    return self.callbacks[event].remove(callback)
            except AttributeError:
                pass

        raise ValueError('Function {!r} is not registered as a {} callback'.format(function, event))
………

@_define_event
def post_run_cell(result):
    """Fires after user-entered code runs.
    Parameters
    ----------
    result : :class:`~IPython.core.interactiveshell.ExecutionResult`
      The object which will be returned as the execution result.
    """
    pass

 

takluyver/backcall

Backwards compatible callback APIs

backcall

Specifications for callback functions passed in to an API

If your code lets other people supply callback functions, it’s important to specify the function signature you expect, and check that functions support that. Adding extra parameters later would break other peoples code unless you’re careful.

backcall provides a way of specifying the callback signature using a prototype function:

from backcall import callback_prototype

@callback_prototype
def handle_ping(sender, delay=None):
    # Specify positional parameters without a default, and keyword
    # parameters with a default.
    pass

def register_ping_handler(callback):
    # This checks and adapts the function passed in:
    callback = handle_ping.adapt(callback)
    ping_callbacks.append(callback)

 

 

 

 

 

 

 

 

 

隨著範例腳步

ipywidgets/docs/source/examples/Index.ipynb

 

好好玩玩各種『小工具』︰

……

 

熟悉認識 IPython 豐富之物件顯示用法︰

………

16 Functions

IPython.display.clear_output(wait=False)

Clear the output of the current cell receiving output.

Parameters:	wait (bool [default: false]) – Wait to clear the output until new output is available to replace it.

IPython.display.display(*objs, include=None, exclude=None, metadata=None, transient=None,display_id=None, **kwargs)

Display a Python object in all frontends.

By default all representations will be computed and sent to the frontends. Frontends can decide which representation is used and how.

In terminal IPython this will be similar to using print(), for use in richer frontends see Jupyter notebook examples with rich display logic.

Parameters:	objs (tuple of objects) – The Python objects to display. raw (bool, optional) – Are the objects to be displayed already mimetype-keyed dicts of raw display data, or Python objects that need to be formatted before display? [default: False] include (list, tuple or set, optional) – A list of format type strings (MIME types) to include in the format data dict. If this is set only the format types included in this list will be computed. exclude (list, tuple or set, optional) – A list of format type strings (MIME types) to exclude in the format data dict. If this is set all format types will be computed, except for those included in this argument. metadata (dict, optional) – A dictionary of metadata to associate with the output. mime-type keys in this dictionary will be associated with the individual representation formats, if they exist. transient (dict, optional) – A dictionary of transient data to associate with the output. Data in this dict should not be persisted to files (e.g. notebooks). display_id (str, bool optional) – Set an id for the display. This id can be used for updating this display area later via update_display. If given as True, generate a new display_id kwargs (additional keyword-args, optional) – Additional keyword-arguments are passed through to the display publisher.
Returns:	handle – Returns a handle on updatable displays for use withupdate_display(), if display_id is given. Returns None if no display_id is given (default).
Return type:	DisplayHandle

───

 

將可讀讀程式，開始想想怎麼寫也。

……

 

 

 

 

 

 

 

 

 

《古文觀止》‧卷十 ‧ 心術論　　蘇洵

為將之道，當先治心。泰山崩於前而色不變，麋鹿興於左而目不瞬 ，然後可以制利害，可以待敵。

凡兵上義，不義，雖利勿動。非一動之為害，而他日將有所不可措手足也。夫惟義可以怒士，士以義怒，可與百戰。

凡戰之道，未戰養其財，將戰養其力，既戰養其氣，既勝養其心 。謹烽燧，嚴斥堠，使耕者無所顧忌，所以養其財；豐犒而優游之，所以養其力；小勝益急，小挫益厲，所以養其氣；用人不盡其所欲為，所以養其心。故士常蓄其怒，懷其欲而不盡。怒不盡則有餘勇 ，欲不盡則有餘貪。故雖并天下，而士不厭兵。此黃帝之所以七十戰而兵不殆也。不養其心，一戰而勝，不可用矣。

凡將欲智而嚴，凡士欲愚。智則不可測，嚴則不可犯，故士皆委己而聽命，夫安得不愚？夫惟士愚，而後可與之皆死。

凡兵之動，知敵之主，知敵之將，而後可與動於險。鄧艾縋兵於蜀中，非劉禪之庸，則百萬之師可以坐縛，彼固有所侮而動也。故古之賢將，能以兵嘗敵，而又以敵自嘗，故去就可以決。

凡主將之道，知理而後可以舉兵，知勢而後可以加兵，知節而後可以用兵。知理則不屈，知勢則不沮，知節則不窮。見小利不動 ，見小患不避，小利小患，不足以辱吾技也，夫然後有以支大利大患。夫惟養技而自愛者，無敵於天下。故一忍可以支百勇，一靜可以制百動。

兵有長短，敵我一也。敢問：「吾之所長，吾出而用之，彼將不與吾校；吾之所短，吾蔽而置之，彼將強與吾角。奈何？」曰：「吾之所短，吾抗而暴之，使之疑而卻；吾之所長，吾陰而養之 ，使之狎而墮其中。此用長短之術也。」

善用兵者，使之無所顧，有所恃。無所顧，則知死之不足惜；有所恃，則知不至於必敗。尺箠當猛虎，奮呼而操擊；徒手遇蜥蜴 ，變色而卻步，人之情也。知此者，可以將矣。袒裼而按劍，則烏獲不敢逼；冠冑衣甲，據兵而寢，則童子彎弓殺之矣。故善用兵者，以形固。夫能以形固，則力有餘矣。

『泰山崩於前』且『麋鹿興於左』，眼見目睹可以置若無聞，可以觸而不動，此『定功』之強，可與『言兵』矣！若夫眼耳鼻舌身意常為『外物』所『觸動』而不得定靜，『事件』川流不斷，目眩而神迷，終將淹沒於『萬象』中，不知其所止耶？

『事件驅動』會意容易，鉤深索隱困難，因為萬象駁雜隨機而發 ，所以『事件』繁亂無序自來。在此就從如何知道『發生了一件事』說起，略探『事件驅動』的基本想法，講講『中斷服務程序』 ISR interrupt service routine 的概念。維基百科『中斷處理』詞條講︰

In computer systems programming, an interrupt handler, also known as an interrupt service routine or ISR, is a callback function in microcontroller firmware, an operating system or a device driver, whose execution is triggered by the reception of an interrupt. In general, interrupts and their handlers are used to handle high-priority conditions that require the interruption of the current code the processor is executing.^[1][2]

Interrupt handlers have a multitude of functions, which vary based on the reason the interrupt was generated and the speed at which the interrupt handler completes its task. For example, pressing a key on a computer keyboard,^[1] or moving the mouse, triggers interrupts that call interrupt handlers which read the key, or the mouse’s position, and copy the associated information into the computer’s memory.^[2]

An interrupt handler is a low-level counterpart of event handlers. These handlers are initiated by either hardware interrupts or interrupt instructions in software, and are used for servicing hardware devices and transitions between protected modes of operation such as system calls.

─── 《勇闖新世界︰ 《 KERNEL 4.X 》之整裝蓄勢‧事件驅動‧一》

 

從 ISR 到

事件驅動程式設計

事件驅動程式設計（英語：Event-driven programming）是一種電腦程式設計模型。這種模型的程式執行流程是由使用者的動作（如滑鼠的按鍵，鍵盤的按鍵動作）或者是由其他程式的訊息來決定的。相對於批次程式設計（batch programming）而言，程式執行的流程是由程式設計師來決定。批次的程式設計在初級程式設計教學課程上是一種方式。然而，事件驅動程式設計這種設計模型是在互動程式（Interactive program）的情況下孕育而生的。

事件驅動程式可以由任何程式語言來實作，然而使用某些語言來撰寫會比其他的語言來的簡單。有些整合開發環境（簡稱IDE）也會影響實作事件驅動程式設計的難易程度。有的 IDE 會使的開發工作變的很簡單，有的則否。

概觀

取代傳統上一次等待一個完整的指令然後再做執行的方式，事件驅動程式模型下的系統，基本上的架構是預先設計一個事件迴圈所形成的程式，這個事件迴圈程式不斷地檢查目前要處理的資訊 ，根據要處理的資訊執行一個觸發函式進行必要的處理。其中這個外部資訊可能來自一個目錄夾中的檔案，可能來自鍵盤或滑鼠的動作，或者是一個時間事件。

對一個事件驅動（event driven）系統進行程式設計，因此可以視為改寫系統預設觸發函式的行為，來符合自己需要的一種動作。輸入的事件可以放進事件迴圈或者是經由已經註冊的中斷處理器來與硬體事件互動；而許多的軟體系統使用了混和這兩種技術的處理。預先設計好的演算法確定了一件事，那就是當他們被需要的時候，就會在適當的時機被觸發。也因此提供了一個模擬中斷驅動環境（interrupt driven environment）的軟體抽象架構。事件驅動程式設計基本上包含了許多小程式片段，這些小程式片段被稱為事件處理器並且被用來回應外部的事件與分發事件。通常尚未被事件處理器處理的事件，都會被系統放在一個稱為事件佇列的資料結構中，等待被處理。

許多情況下，事件處理器可以自己觸發事件，因此也可能形成一個事件串。 事件驅動程式設計的著重於彈性以及非同步化上面，並且企圖盡可能的 modeless 。 圖形化使用者介面這類程式就是典型的事件驅動設計方式。

電腦作業系統是事件驅動程式的典型範例。在作業系統的最底層 ，中斷處理器的動作就像是硬體事件的直接處理器，搭配著 CPU 執行分配事件規則動作。對軟體處理程式而言，基本上作業系統可視為一個事件分配器，傳送資料和軟體中斷給使用者自己寫的軟體處理程式。

 

典範，不知幾里路遙也？

倘以

DOM events

DOM (Document Object Model) events allow event-driven programming languages like JavaScript, JScript, ECMAScript, VBScript and Java to register various event handlers or listeners on the element nodes inside a DOM tree, such as in HTML, XHTML, XUL and SVG documents.

Historically, like DOM, the event models used by various web browsers had some significant differences. This caused compatibility problems. To combat this, the event model was standardized by the World Wide Web Consortium (W3C) in DOM Level 2.

Events

HTML events

Common events

There is a huge collection of events that can be generated by most element nodes:

• Mouse events ^[1][2]
• Keyboard events
• HTML frame/object events
• HTML form events
• User interface events
• Mutation events (notification of any changes to the structure of a document)
• Progress events^[3] (used by XMLHttpRequest, File API,^[4] …)

Note that the event classification above is not exactly the same as W3C’s classification.

 

數量考察之，果然繁且重矣！

幸而 ipywidgets 藉著特徵小程式

ipython/traitlets

A lightweight Traits like module https://traitlets.readthedocs.io/

Traitlets

home	https://github.com/ipython/traitlets
pypi-repo	https://pypi.org/project/traitlets/
docs	https://traitlets.readthedocs.io/
license	Modified BSD License

Traitlets is a pure Python library enabling:

• the enforcement of strong typing for attributes of Python objects (typed attributes are called “traits”);
• dynamically calculated default values;
• automatic validation and coercion of trait attributes when attempting a change;
• registering for receiving notifications when trait values change;
• reading configuring values from files or from command line arguments – a distinct layer on top of traitlets, so you may use traitlets without the configuration machinery.

Its implementation relies on the descriptor pattern, and it is a lightweight pure-python alternative of the traits library.

Traitlets powers the configuration system of IPython and Jupyter and the declarative API of IPython interactive widgets.

……

Using Traitlets

In short, traitlets let the user define classes that have

1. Attributes (traits) with type checking and dynamically computed default values
2. Traits emit change events when attributes are modified
3. Traitlets perform some validation and allow coercion of new trait values on assignment. They also allow the user to define custom validation logic for attributes based on the value of other attributes.

───

 

將回呼函式 callback 歸納為兩種，方便以簡馭繁呦◎

※ 註

觀察者模式

Observer pattern

The observer pattern is a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods.

It is mainly used to implement distributed event handling systems, in “event driven” software. Most modern languages such as C# have built in “event” constructs which implement the observer pattern components, for easy programming and short code.

The observer pattern is also a key part in the familiar model–view–controller (MVC) architectural pattern.^[1] The observer pattern is implemented in numerous programming libraries and systems, including almost all GUI toolkits.

Overview

The Observer ^[2] design pattern is one of the twenty-three well-known “Gang of Four” design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse.

What problems can the Observer design pattern solve?

The Observer pattern addresses the following problems:^[3]

• A one-to-many dependency between objects should be defined without making the objects tightly coupled.
• It should be ensured that when one object changes state an open-ended number of dependent objects are updated automatically.
• It should be possible that one object can notify an open-ended number of other objects.

Defining a one-to-many dependency between objects by defining one object (subject) that updates the state of dependent objects directly is inflexible because it commits (tightly couples) the subject to particular dependent objects. Tightly coupled objects are hard to implement, change, test, and reuse because they refer to and know about (how to update) many different objects with different interfaces.

What solution does the Observer design pattern describe?

• Define Subject and Observer objects.
• so that when a subject changes state, all registered observers are notified and updated automatically.

The sole responsibility of a subject is to maintain a list of observers and to notify them of state changes by calling their update() operation.
The responsibility of observers is to register (and unregister) themselves on a subject (to get notified of state changes) and to update their state (synchronize their state with subject’s state) when they are notified.
This makes subject and observers loosely coupled. Subject and observers have no explicit knowledge of each other. Observers can be added and removed independently at run-time.
This notification-registration interaction is also known as publish-subscribe.

A sample UML class and sequence diagram for the Observer design pattern. ^[7]

 

 

 

 

 

 

 

 

 

在《 Physical computing ︰《二》 GPIO 初探》文本中，引用了一段小王子與小狐狸的對話︰

小狐狸很關心『雞』與『獵人』，小王子想知道什麼是『馴服』 。這可真是『同中有異』且又『異中有同』，並非是雞同鴨講之事。既然小狐狸與小王子都沒有『名字』，只是個『稱謂』，某個類中『之一』。這『馴服』之神奇，就在能將『之一』化成『唯一』。也許此『馴服』所建立之『聯繫』，恰似老子所言︰

無名天地之始，有名萬物之母。

。天地只需一個『風箱』就可生化『萬有』聯繫『萬象』︰

老子說︰天地之間，其猶橐ㄊㄨㄛˊ籥ㄩㄝˋ乎？虛而不屈，動而愈出。這個『橐籥』就是風箱和鼓風的管子，那天下沸騰該怎麼辦呢？揚湯止沸只顧得了一時，釜底抽薪果真就能長久？或許這當問問莊子，天籟之聲是否出自橐籥？它是否象一根鬆緊之弦？太鬆了又發不出聲，太緊了它或會繃斷！！

─── 先生ㄚ！你並沒有解釋『這個問題』，你只是把它丟給『那個問題』。───

─── 引自《馬太福音 25:29；》

 

，表現卻『各各不同』。

由此看來 Miller Puckette 之『純數據』 pure data 所謂的『箱子』 ，亦是『無名』之『器物』，『指示』所用之『符號』事實上不過是『功能模型』的『代稱』而已。如是不管『箱子』的『接線 』、『控制』、『狀態』…… 都不是『先驗』之事，當下的『操作 』、『次序』、『改變』…… 全具有『時物』之情。或許從『實踐 』中『學習』，正是 Miller Puckette 的設計理念吧！！

如是我們雖不該將『簡單』的事情給『複雜化』了。但是『單純 』之『箱子』理念卻也不能隨意的『簡單化』。畢竟那『箱子』的『入出口』還有著『冷熱』、『先後』，『規矩』、『內外狀態』 …… 之種種區分的耶。何妨

看圖說故事乎？？

─── 《勇闖新世界︰ W!O《卡夫卡村》變形祭︰品味科學‧教具教材‧【專題】 GEM‧PD‧冷熱先後》

 

如果今天還不熟悉

HTML

Hypertext Markup Language (HTML) is the standard markup language for creating web pages and web applications. With Cascading Style Sheets (CSS) and JavaScript, it forms a triad of cornerstone technologies for the World Wide Web.^[4]

Web browsers receive HTML documents from a web server or from local storage and render the documents into multimedia web pages. HTML describes the structure of a web page semantically and originally included cues for the appearance of the document.

HTML elements are the building blocks of HTML pages. With HTML constructs, images and other objects such as interactive forms may be embedded into the rendered page. HTML provides a means to create structured documents by denoting structural semantics for text such as headings, paragraphs, lists, links, quotes and other items. HTML elements are delineated by tags, written using angle brackets. Tags such as <img /> and<input /> directly introduce content into the page. Other tags such as <p> surround and provide information about document text and may include other tags as sub-elements. Browsers do not display the HTML tags, but use them to interpret the content of the page.

HTML can embed programs written in a scripting language such as JavaScript, which affects the behavior and content of web pages. Inclusion of CSS defines the look and layout of content. The World Wide Web Consortium (W3C), maintainer of both the HTML and the CSS standards, has encouraged the use of CSS over explicit presentational HTML since 1997.^[5]

 

語言之『三位一體』的人，沒有關係！

假使昨天也沒有接觸過『圖形化使用者界面』，沒有關係！！

Graphical user interface

The graphical user interface (GUI /ɡuːiː/), is a type of user interface that allows users to interact with electronic devices through graphical icons and visual indicators such as secondary notation, instead of text-based user interfaces, typed command labels or text navigation. GUIs were introduced in reaction to the perceived steep learning curve of command-line interfaces (CLIs),^[1][2][3] which require commands to be typed on a computer keyboard.

The actions in a GUI are usually performed through direct manipulation of the graphical elements.^[4] Beyond computers, GUIs are used in many handheld mobile devices such as MP3 players, portable media players, gaming devices, smartphones and smaller household, office and industrial controls. The term GUI tends not to be applied to other lower-display resolution types of interfaces, such as video games (where head-up display (HUD)^[5] is preferred), or not including flat screens, like volumetric displays^[6] because the term is restricted to the scope of two-dimensional display screens able to describe generic information, in the tradition of the computer scienceresearch at the Xerox Palo Alto Research Center.

the interim Dynabook GUI (Smalltalk-76 running on Alto)

 

憑借『經驗』之『聯繫』，不必分馴服或被馴服之早晚先後也，何必辨『 □ ○』 與『○ □ 』關係間之主從耶？

因是能以想像羽翼，乘風翱翔易乎？？