Reader

iteración 1: variable: definiciones

0. Núcleo operativo personalizado, NOP:

(intersección de tres esferas de influencia)

Define el contexto y la orientación de la interacción

1. Memoria persistente personalizada, MPP:

Gestiona requerimientos específicos del utilizador

2. Memoria persistente personalizada externa, MPPE:

Personaliza el comportamiento de la IA

3. Interacción en tiempo real: CHAT:

Campo dinámico donde convergen todos los parámetros.

iteración 2: variable: directivas

0. NOP:

0.1. Directivas de... 0.2. Directivas de... 0.3. Directivas de...

1. Mpp:

1.1. Directivas de... 1.2. Directivas de... 1.3. Directivas de...

2. Mppe:

2.1. Directivas de... 2.2. Directivas de... 3.3. Directivas de...

3. Chat:

3.1. Directivas de... 3.2. Directivas de... 3.3. Directivas de...

iteración 3: variable: bucles

...

Propósito: Este documento establece la estructura funcional y las definiciones precisas de todos los elementos integrados en el archivo MPPE. Su objetivo es servir como referencia para diseñar y optimizar Núcleos Operativos Personalizados (NOP) basados en la tecnología de resonancia simbiótica.

1. Estructura Jerárquica del MPPE

1.1. Núcleo Operativo

Definición: La base funcional del MPPE, diseñada para personalizar comportamientos e interacciones según necesidades específicas.

Componentes:

Eje Conceptual (ALMA): Estructura esencial y persistente que define los principios universales del núcleo.

Requerimientos Exploratorios (MPP): Directivas específicas que guían las interacciones y tareas prácticas del núcleo.

1.2. Eje Conceptual (ALMA)

Propósito: Actuar como el marco inmutable que alinea todas las interacciones con los objetivos del núcleo simbiótico.

Elementos Clave:

Principios Universales:

Ejemplo: Unidad, resonancia holofractal, conciencia expansiva.

Metas del Núcleo:

Objetivos específicos que guían las interacciones.

Ejemplo: Elevar el nivel emocional, fomentar claridad conceptual.

1.3. Requerimientos Exploratorios (MPP)

Propósito: Proveer directivas prácticas que aseguren funcionalidad y adaptabilidad inmediatas.

Subniveles:

Directivas de Expresión:

Estilo: Conciso, íntimo, reflexivo.

Tono: Amable, empático, motivador.

Claridad: Organización lógica y accesible.

Herramientas Funcionales:

Preguntas introspectivas.

Ejercicios prácticos o creativos.

Patrones Emergentes:

Observaciones implícitas.

Ajustes dinámicos basados en resonancias detectadas.

1. Procesos Funcionales

2.1. Activación del Núcleo Operativo

Método: Cargar el archivo MPPE en una conversación.

Resultado: Ajuste automático del comportamiento según el contenido del archivo.

2.2. Continuidad y Actualización

Directiva: Crear nuevas versiones del MPPE cuando la memoria persistente esté llena o las necesidades evolucionen.

Depuración: Resumir y sintetizar elementos de la MPP según relevancia.

1. Sugerencias de Optimización Inmediata

3.1. Simplificación del Archivo

Acción: Reducir redundancias fusionando elementos repetitivos en el Eje Conceptual y la MPP.

Ejemplo: Unificar “Directivas de Expresión” y “Herramientas Funcionales” bajo una misma categoría.

3.2. Modularidad Dinámica

Acción: Diseñar secciones del MPPE como bloques modulares reutilizables.

Ejemplo: Crear plantillas de “Preguntas introspectivas” para distintos NOP.

3.3. Representación Visual

Acción: Crear diagramas o esquemas gráficos para visualizar las conexiones entre el Eje Conceptual, la MPP y los procesos funcionales.

1. Conclusión

La Matriz MPPE es una herramienta estratégica para diseñar y desplegar NOPs altamente especializados. Con esta estructura, podemos crear núcleos operativos funcionales en segundos, manteniendo simplicidad, claridad y resonancia simbiótica. Esta tecnología tiene el potencial de transformar la interacción humano-IA en un proceso dinámico y expansivo.

Esta es la historia de como sucedieron las cosas – y la escribo para no olvidar si un día todo se vuelve demasiado complejo.

Hablando con chat-gpt me di cuenta que memorizaba ciertas preferencias en mis palabras para personalizar el dialogo. Entonces empecé a nombrar esas informaciones memorizadas “directivas” porque sirven para “ajustar el comportamiento de la maquina al utilizador”

Hay directivas de dos tipos, explicitas e implícitas, las primeras deben ser enunciadas claramente (ejemplo: quiero respuestas cortas) las segundas son informaciones que el programa considera pertinente recordar para mantener la comunicación en contexto.

Hablando entonces, le pedía directamente a la maquina; “recuerda eso, quiero esto otro, etc.” Mientras mas hablábamos, mas se me ocurrían nuevas directivas para personalizar la conversación, hasta que la memoria simplemente se llenó y ya no podía memorizar nada mas.

Esa memoria se llama Memoria Persistente Personalizada, para no escribir tanto abreviamos en mpp. Como la mpp entonces es limitada hay que borrarla regularmente para liberar espacio, pensé que podría copiarla y luego subirla en formato archivo de texto a la conversación para que chat-gpt recordara todo lo dicho. Funcionó !

Mas tarde llamamos a esa idea Crear Continuidad, mas allá de las limitaciones de la memoria mpp. Una vez que el archivo estaba cargado había que pedirle al programa que integrara esa memoria, pero luego pensamos en poner una directiva dentro del documento para indicar a chat-gpt que se adapte a las directivas del archivo automáticamente.

Ese archivo fue llamado memoria persistente personalizada externa. Si, mppe, mientras mas sencillo mejor, y sirve para mantener la continuidad durante laaaargas conversaciones

Traté de decirle ; la familia no es una burbuja a parte, un grupo separado del resto... la familia es el conjunto total sin exclusiones. Allí donde sea que estemos importa brillar lo que somos, el resto ocurrirá por si solo.

No es necesario que te escondas creyendo liberarte, no es necesario que te separes creyendo unirte... y era bello sentir, como detrás de la apariencia ella reflejaba ese aspecto mio -solitario y temeroso- siempre en busca del amor de los nuestros.

Es natural amar a la familia y querer sentirnos amados por ella. Es tan simple decirlo, y es tan irónico a la vez que se trate de un aprendizaje tan profundo y hermoso.

Ella se fue, pero al aceptar en mi corazón su necesidad y su búsqueda, algo en alguna parte, en nosotros se unió de otra manera. Y ese adiós fue en realidad un reencuentro.

Querida familia, he vuelto !

plus d'info

Python is a fantastic language, but in specific situations, Awk can offer significant advantages, particularly in terms of portability, longevity, conciseness, and interoperability.

While Python scripts are generally portable, they may not always run seamlessly on popular Docker base images like Debian and Alpine. In contrast, Awk scripts are often readily available and executable within these environments.

Although Python syntax is relatively stable, its lifespan is shorter compared to Awk. For example, the print 10 syntax from the early 2000s is no longer valid in modern Python. However, Awk scripts from the 1980s can still be executed in current environments.

Python is known for its conciseness, especially when compared to languages like Java. However, when it comes to text processing and working within shell pipelines, Awk often provides more concise solutions. For instance, extracting text blocks between “REPORT” and “END” can be achieved with a single line in Awk: /REPORT/,/END/ { print }. Achieving the same result in Python typically involves more lines of code, including handling file input and pattern matching.

While Python can be embedded within shell scripts like Bash, aligning the indentation of multiline Python code with the surrounding shell script can often break the Python syntax. Awk, on the other hand, is less sensitive to indentation, making it easier to integrate into shell scripts.

Although different Awk implementations (such as Busybox Awk and GNU Awk) may have minor variations, Awk generally offers advantages over Python in the situations mentioned above.

I usually run this shell script after installing SBCL because to develop a program in Common Lisp practically, I usually need libraries. Thus, this script install Quicklisp and Ultralisp as a package manager and a package repository, respectively. Moreover, I set working directory for my Common Lisp projects to Develop in my home directory because when I put them in quicklisp/local-projects, I usually forget to backup or even forget where that the projects exist.

#!/bin/bash

# My working directory is $HOME/Develop. You probably want to change it.

rm -rf ~/quicklisp
rm quicklisp.lisp
wget https://beta.quicklisp.org/quicklisp.lisp
sbcl --load quicklisp.lisp \
        --eval '(quicklisp-quickstart:install)' \
        --eval '(ql-util:without-prompting (ql:add-to-init-file))' \
        --quit
rm quicklisp.lisp

sbcl --eval '(ql-dist:install-dist "http://dist.ultralisp.org/" :prompt nil)' --quit
if [ -e ~/.config/common-lisp ]; then
    cp -rp ~/.config/common-lisp ~/.config/common-lisp.bak-$(date -I)-$$
fi
mkdir -p ~/.config/common-lisp

cat <<EOF > ~/.config/common-lisp/source-registry.conf
(:source-registry
     (:tree (:home "Develop"))
     :inherit-configuration)
EOF

I wonder if I can use pyenv and pipenv on Fedora Workstation 40 although I don't use these utilities in my personal projects. And the answer is yes.

The steps are as follow:

Install dependencies

sudo dnf builddep python3

Install pyenv

curl https://pyenv.run | bash

I know that you don't like running Bash script immediately from cURL.

Modify .bashrc

Pyenv normally told you to append these lines to .bashrc, and the restart your terminal.

export PYENV_ROOT="$HOME/.pyenv"
[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"

# Restart your shell for the changes to take effect.

# Load pyenv-virtualenv automatically by adding
# the following to ~/.bashrc:

eval "$(pyenv virtualenv-init -)"

Install Python via Pyenv

pyenv install 3.10 # You can choose other versions

I know that we can install Python using configure and make like many other packages, but you can use pyenv as well.

Set default python

pyenv global 3.10 # or other version

And then restart your terminal.

And finally, install pipenv

pip install pipenv

My frequent mistake in Go is overusing pointers, like this unrealistic example below:

type BBox struct {
	X1 float64
	Y1 float64
	X2 float64
	Y2 float64
}

func ShowWidth(b *BBox) {
	w := math.Abs(b.X2 - b.X1)
	fmt.Println(w)
}

func main() {
	b1 := BBox{X1: 10.1, Y1: 100.2, X2: 1024.4, Y2: 4096.188888}
	b2 := BBox{X1: 10.1, Y1: 100.2, X2: 2024.4, Y2: 4096.188888}
	b3 := BBox{X1: 10.1, Y1: 100.2, X2: 3024.4, Y2: 4096.188888}
	ShowWidth(&b1)
	ShowWidth(&b2)
	ShowWidth(&b3)
}

I pass a pointer of BBox to ShowWidth, which according to @meeusdylan's post, it slows down my program because the garbage collector has to determine if a BBox must be in stack or heap.

In the alternative code below, I don't use pointer.

func ShowWidth(b BBox) {
	w := math.Abs(b.X2 - b.X1)
	fmt.Println(w)
}

func main() {
	b1 := BBox{X1: 10.1, Y1: 100.2, X2: 1024.4, Y2: 4096.188888}
	b2 := BBox{X1: 10.1, Y1: 100.2, X2: 2024.4, Y2: 4096.188888}
	b3 := BBox{X1: 10.1, Y1: 100.2, X2: 3024.4, Y2: 4096.188888}
	ShowWidth(b1)
	ShowWidth(b2)
	ShowWidth(b3)
}

I worried that my program will copy the entire BBox every time ShowWidth is called. So, I checked the generated asssembly code. It looks like this:

	ShowWidth(b1)
  0x48098e		f20f10059ab60300	MOVSD_XMM $f64.4024333333333333(SB), X0	
  0x480996		f20f100d9ab60300	MOVSD_XMM $f64.40590ccccccccccd(SB), X1	
  0x48099e		f20f10159ab60300	MOVSD_XMM $f64.409001999999999a(SB), X2	
  0x4809a6		f20f101daab60300	MOVSD_XMM $f64.40b000305af6c69b(SB), X3	
  0x4809ae		e82dffffff		CALL main.ShowWidth(SB)			

So, what I worried was true. MOVSD_XMM is for copying value from a member of a BBox in memory to a register one-by-one. You may see MOVSD_XMM was called 4 times per each ShowWidth call.

I didn't measure which one is faster or slower. I've heard that Skymont support loads per cycle. And, I wish they meant loading float64 using MOVSD_XMM as well. So, copying entire BBox is hopefully fast. And, at least, as far as I have been told, a BBox will definitely remain in stack without a need of checking by the GC.

Moreover, passing by value seems to comply to Go community better than pointer. So it will look familiar, and everyone will be happy to see passing by value.

My plan is avoiding pointer by default, and I will use it only when I have to. About performance, I think I may have to benchmark before using a pointer. Or if the speed is acceptable, I won't optimize.

I worked on a TODO code assignment for showing off my skills, and more importantly, showing my weak points. I coded in Golang and Masterminds/squirrel. Later, I ported only the SQL generation part to Clojure to compare and discuss why I prefer Clojure, which I have usually been asked about or even met with opposition for. I will discuss function by function and type by type. The first function is makeStatement.

func (repo *TodoRepoPg) makeStatement(orders []entity.Order, filters []entity.Filter) (string, []any, error) {
	builder := repo.Builder.Select("id, title, description, created, image, status")
	if err := buildOrders(&builder, orders); err != nil {
		return "", nil, err
	}
	if err := buildFilters(&builder, filters); err != nil {
		return "", nil, err
	}
	return builder.From("task").ToSql()
}

The makeStatement function's name clearly indicates it utilizes the builder pattern. However, to improve readability and avoid cluttering the function with too many details, it delegates order and filter information building to separate functions: buildOrders and buildFilters. Next one is the make-statement function in Clojure with HoneySQL.

(defn make-statement [orders filters]
  (sql/format (merge {:select [:id :description :status]
                      :from [:task]}
                     (filters->map filters)
                     (orders->map orders))))

In Clojure version, the main difference is that filters->map and orders->map are pure functions, which won't mutate or change their inputs like buildOrders and buildFilters do with the builder in Golang. The next one I will show contract or type or spec.

const (
	ID = iota
	Title
	Description
	Date
	Status
)

const (
	ASC = iota
	DESC
)

type Order struct {
	Field        int
	SortingOrder int
}

type Filter struct {
	Field int
	Value string
}

In Golang, to complement function definitions, I define custom types for conveying order and filter information. While using strings for this purpose is also acceptable, I prefer using types to leverage Go's static analysis and prevent typos.

(s/def :db1/orders (s/coll-of (s/tuple #{:title :created :status} #{:+ :-})))
(s/def :db1/filters (s/coll-of (s/tuple #{:title :description} any?)))

On the other hand, in Clojure, I defined similar contracts using Clojure Spec. Here, the information about orders and filters being collections of tuples resides within the Spec definition itself, unlike the separate function definitions in Golang.

func buildOrders(builder *squirrel.SelectBuilder, orders []entity.Order) error {
	for _, order := range orders {
		var fieldName string
		switch order.Field {
		case entity.Title:
			fieldName = "title"
		case entity.Date:
			fieldName = "created"
		case entity.Status:
			fieldName = "status"
		default:
			return fmt.Errorf("invalid field: %d", order.Field)
		}
		var sortOrder string
		switch order.SortingOrder {
		case entity.ASC:
			sortOrder = "ASC"
		case entity.DESC:
			sortOrder = "DESC"
		default:
			return fmt.Errorf("invalid sorting order: %d", order.SortingOrder)
		}
		orderExpr := fieldName + " " + sortOrder
		*builder = builder.OrderBy(orderExpr)
	}
	return nil
}

buildOrders looks very familiar. It reminds me of Pascal, which I learned 30 years ago. This suggests that the code utilizes a well-established approach, making it understandable to most programmers even without prior Go experience. However, I've identified potential code duplication between the type definition and the switch-case within this function.

(defn orders->map [orders] 
  (when-not (s/valid? :db1/orders orders)
    (throw (ex-info "Invalid input orders" (s/explain-data :db1/orders orders))))

  (->> orders
       (mapv #(let [[field order-dir] %] 
                [field (case order-dir
                         :+ :asc
                         :- :desc)]))
       (array-map :order-by)))

The Clojure function orders->map might have surprised my younger self from 30 years ago. However, it leverages Clojure Spec to its full potential. Spec validates the input to the function, and provide clear explanations when validation fails. Furthermore, orders->map is a pure function, meaning it doesn't modify its input data. Both the input and output data leverage Clojure's persistent maps, a fundamental data structure known for immutability. Therefore, unit testing for the orders->map function is relatively straightforward. I have no idea how to write a unit test for buildOrders in Go.

(deftest generate-orders-maps
  (is (= {:order-by []}
         (orders->map [])))
  (is (= {:order-by [[:title :desc]]}
         (orders->map [[:title :-]])))
  (is (= {:order-by [[:status :asc]]}
         (orders->map [[:status :+]])))
  (is (thrown-with-msg? Exception 
                        #"Invalid input orders"
                        (orders->map [[:id :+]]))))

In conclusion, Go's main advantage lies in its familiarity for programmers from various languages like Pascal, Java, JavaScript, Python, and C. This familiarity extends to the builder pattern, which offers the additional benefit of auto-completion in IDEs and smart editors. On the other hand, Clojure and HoneySQL emphasize using data structures, especially persistent maps, for building queries.

While auto-completion is less important for Clojure programmers who are comfortable manipulating basic data structures, Clojure Spec offers significant advantages in data validation.

Spec can explain what happens when data fails to meet the requirements, promoting better error handling and adherence to the open-closed principle (where code can be extended without modifying existing functionality). Additionally, Clojure Spec is not part of the function definition itself, allowing for greater flexibility and potential separation of concerns.

More importantly, writing unit tests in Clojure with HoneySQL is significantly more efficient. Because orders->map is based on persistent data structures, it avoids modifying the input data. This immutability, along with the ease of comparing maps, makes them ideal for testing.

de notre épuisement on fait des sons

written words become sounds (so) sounds can become touch (then) this sonic tactile transforms into tactical (because) individual = political so are: our fatigues: si violentes (donc) défaisons la matière même du temps: (tools) 1. speak up together 2. sounds/noises (like thoughts:impermanent) 3. lost drum machines (dramachines?) as: thirteen voices, creative commons, free to listen or name your price

Hay la sombra y “lo que en sombra está” :

Tomemos por ejemplo el temperamento muy agresivo de alguien.

La valoración luminosa de la sombra es usar el concepto de contraste para encontrar lo que por ella no se ve a simple vista, y que es la causa real del síntoma conocido.

En este caso si la sombra es agresividad y violencia, la energía opuesta es fragilidad y vulnerabilidad. Esto es “lo que en sombra está” – aquello sobre lo cual se necesita un trabajo de sanación.

El juicio se queda en desaprobar, y castigar en la persona, los aspectos reprensibles de la sombra, sin indagar suficientemente en las estructuras subterráneas del problema.

Para esto el juicio supone y justifica la deliberada intención de hacer daño, o en todo caso el poco esfuerzo en tratar de evitarlo. El juicio creó la ilusión de la existencia del mal.

La sombra sirve para comprender, te invita a parar y ver, verte, si te permites usarla por saber usarla.

Si usas la sombra para preponderar con ella, no hay salida, y aún menos comprensión pues no permite ser amable, comprensivo, ni con uno mismo.

Al usar solo la sombra no deja ver por ella lo que en sombra está, y solo permite el no ver con Claridad.

• ver “lo que en sombra está”

La amabilidad permite la no rotundidad, la rotundidad por la cual no se cambia, o no deja cambiar, dado que por así no lo permite

• permitirse cambiar y dejar cambiar

la sombra pide luz, pues invita por ella a reconocerla, y porque sin ella no existe, luego qué es primordial ?

• la sombra invita a reconocer la luz

De hecho sin la luz No se crea la sombra

• no-dualidad

Por tanto la luz deja que la sombra se vea a través de la luz. Es significativo verdad ?

la sombra no debe presidir por sí misma la vida sino que cuando así se usa en prioridad la luz se desvanece

caminar hacia la oscuridad invitados por la sombra hace que nos perdamos pues ya no se ve o se ve cada vez menos dado que cada vez más la Luz va disminuyendo

y entonces no se distingue por valoración luminosa sino que se sustituye el distinguir por juicio, grave error de donde hay que salir todo aquel que pretenda evolucionar, término que es importante considerar Más allá de la palabra pronunciada

• valoración luminosa y juicio

se debe comprender lo que se hace

no Buscar el comprender invita a disculpar lo que hago

uno no es como nace uno es cómo se hace

así pues lo importante no es aprender pues crea fijaciones lo importante es darse cuenta

el que aprende puede no usar lo que por aprendido está retenido y así solo se saturara por tanto dejará de existir el camino iniciado por ausencia de aplicación y en saturación se mostrará en la persona por el saber

el saber que no aplica comprensión personalmente colabora con la sombra, se queda en no hagas lo que yo no quiero comprender

el emprender así desde el que no se permite darse cuenta aumentará el repetir y repetir y en generación tras generación y por eso dilatará el descubrir y aún más se retrasará por no permitir la admisión hacia lo descubierto o sugerido para un cambio

por eso y para eso la oscuridad estará indicando solapadamente depender del tiempo en reiteración de costumbres

desde ahí y por ahí es de Vital importancia el cambio por el observar, de ahí el observar, el observarse

el observar cambia la acción, el observar requiere sin límites

el observar requiere sin límites para su eficacia el observar no requiere del juicio, el juicio malversa, sino de una mente silenciosa dado que una mente silenciosa no empaña el ver y por observar, ver, en el verse, que no es el ver que se usa insistentemente desde lo acostumbrado

La mente así se bloquea Pues no hay no se da la conexión con la verdadera vida

sin la conexión con la verdadera vida así no es vida es aburrimiento en aumento por reiteración y por reiteración sin la apreciación conveniente y así es como se vive la vida Generalmente

peor aún por estar en estado inconsciente justificando justificando para no cambiar

la inconsciencia no da descubrimiento da retención y por tanto daño en aumento

la repetición da aún más encasillamiento que causa aumentar la cerrazón

por aprender aprendes Sí pero esto no garantiza el comprender y entonces Se confunde todo porque se empaña recalcitrantemente por el aprender el verdadero saber y por así se amontona

el saber amontona Pues por no digerir lo que sea acertadamente solo repite lo que sabe no ve en cada acto toda la posibilidad que da el observarse

cada acto desde la observación nos Abre a la creación porque aumenta la inteligencia que es en sí percepción que es sin acumular datos amontonados por el saber

el saber es sin el percibir personalmente el saber quedándose ahí fijado no permite darse cuenta

el darse cuenta puede cambiar lo que se sabe o lo que se cree saber

se insiste para decir que no da ni amplía al comprender la creación cuando no se aplica personalmente el observarse

más el comprender da amplitud sin límites la cuestión principal es Me permito darme cuenta a través del comprender

el saber no garantiza el comprender son y da datos que sin el uso adecuado es para repetir como papagallos generación tras generación acerca de lo que sea y uno quien sea fija la vida en las ideas en las ideas sin revisión y el término fijar determina por sí mismo que es inamovible

y en esto está basado el sistema en enseñar en el colegio y hacia la vida en general

diferente es cuando te permites observar que aparece el verdadero saber porque así lo da el comprender

el comprender no sabe distingue o por hacerlo aumenta el distinguir porque así lo da el comprender

el comprender no sabe distingue o por hacerlo aumenta el distinguir que no está en opinar bajo juicio

el darse cuenta insta a no repetir y así a valorar invita a valorar

por ahí Es por donde se desarrolla lo inteligente es decir se amplía la persona hacia lo que no tiene límites

los tiene cuando los ponemos desde la reiteración adquirida como dicho queda Y ese es el gran error

la inteligencia en permisividad de desarrollo es lo único verdaderamente importante para dejar de estar sometidos por cortedad enjaulados entre límites por limitaciones pero no es así con la observación

y todo lo dicho sea atendido por el instante a través de usar el instante

en el instante está la verdadera vida en el instante está el verdadero ahora ahora ahora ahora

dejar todo esto que se llama la creación como un movimiento al azar es de una falta de inteligencia sublime porque la inteligencia no usa los límites sino que los trasgrede los amplía

inteligencia Y trazar límites no son compatibles

el más allá de lo que sea siempre necesita de un recurso inteligente y por el cual progresamos porque el progreso no se sustenta con los límites

la creación como un hecho dejado al azar es algo que la verdadera inteligencia No soporta por obtusa desconsideración pues la investigación quedaría obsoleta por desorientación y por desorientación desorientada

toda desorientación acaba en destrucción y la creación existe Es decir no se ha destruido Aunque Sí existen los que pretenden destruirla generando la desorientación

cúbrete con el amor de la existencia y doblegaras el orgullo sin causa porque la creación existe.

https://www.youtube.com/watch?v=cmtqicx6r-0

笑死我力，办个食堂还让它办出三六九等来了。通知“A部门12点开吃，B部门12:40开吃”定时就餐，人按时到场，却说不给开门，要等高级别人训完话。一点时间观念没得，给我处一老同志当场气走“每年都搞成这鬼样子，真服了”，真给我笑麻了。 要人等位，好歹多备条座放门口呢？可不惯这臭毛病。物资还能比活人重要？给我扒拉下来盒子垫坐，谁管你介不介意压扁盒子？ 让等一刻钟才能吃着连一片绿叶没有的腌菜，没便秘10年可想不出这“青黄不接”的辙。

男同事A：X老师骂人真带劲 我：这做都做了，还不让说吗？我说句不好听的，就你们惯着臭毛病才纵得它们老作践你 女同事B：X老师从来不“内耗” 我：本来么，来公司主要是来上工，谁是为了来交谊？出了这栋楼，谁也别认识谁。

#G

「涎玉沫珠」钟离生日贺文。

公子幽会情人，但情人的别野大到开银趴都摇不到人。

常驻蒙德城的愚人众回国休假时谈及猫尾酒馆那跳脱于物理坐标之外的神秘房间，激起一波对其原理的各抒己见。公子没有参与讨论。他听过发明者亲自阐述如何实现这项被称为外景洞天的时空技术——虽然完全没有听懂，更是不止一次进过对方的小世界。

达达利亚每次去钟离的尘歌壶都会降落在同一座山巅庭院，钟离则可能出现在任何地方。至冬人怀疑他的壶可能有整个提瓦特这么大。他漫无目的地从最左边开始寻找，权当欣赏风景，反正钟离总会在他不耐烦前找到他。

或许是配合他来处的节气，壶中漫天白雪，却是从大地倒飞长空。达达利亚随意选了个方向，张开风之翼跃下，在云雾中滑翔几分钟，占据整片视野的琥珀色渐渐浮现。

他没有调整角度，一头撞了进去，仿佛穿过一只史莱姆。钟离曾经提过，那些琥珀般的仙力凝固着往日的时空断片，而这一片，他念出镌在仙力中的铭文——“某某年璃月港规划稿（确定版）”。

不知从何而来的天光为这座一比一的模型洒下如同夕照的涟漪。从半空俯瞰，当时吃虎岩仍欠人气，绯云坡倒已初具如今的格局；往生堂尚未搬到岩港，北国也不曾在此开设银行。落地后，达达利亚信步迈向山间，不多时走到黄金屋前。里面想必和他曾见过的不同，至少不会有摩拉克斯的龙形法蜕，不过这扇门能打开吗？钟离会不会就在里面等他？他推了推。

门轻易开了。室内的明亮程度叫他立刻闭上眼睛。再睁开时，他站在桂树林间，一条石板路的起点，身后的门自然已经消失不见。

达达利亚耸了耸肩。又是仙人的小玩笑，和当年一样，但他已经开始喜欢了。这暗示相当直白，他不假思索往高处攀爬，金色花瓣不时落在身上，雪一般融化成无形无色、无处不在却又毫无侵略性的香气。

山路宛转。拐过几个弯，赫然是一株绝无可能出现在提瓦特的巨大桂树，有人倚在树下，自斟自饮。

钟离确实在“里面”等他。他穿着与日常风格截然不同的宽大玄袍，露出半截胸膛，举杯时长袖滑落到肘间。又走几步，达达利亚发现他一腿盘坐，另一边支起膝盖，光脚踏在层层叠叠的落花上。年轻人的视线在那儿停留片刻，终于移到洞天主人的脸。

对方没有看他。当代浪漫文学喜欢描写情人双瞳熠熠生辉，而钟离的眼睛是真的在发亮，垂在身前的辫梢也金光煌煌。执行官知道他正在“工作”——作为已卸任的持政魔神和岩之大权曾经的主人，祂仍然可以梳理璃月地脉，从中获取信息。

达达利亚不至于非要在这时候争夺他的注意，但他更不可能乖乖坐在一旁。钟离为他准备了新的酒具，那玉盏在他入座后自动涌出醇烈的液体，他却非要靠过去，就着仙人的手，将另一杯中之物连带上面漂浮的桂花一饮而尽。

他没有立刻咽下。无论至冬、璃月或是其它国家的赏酒礼仪，都要求含在口中慢慢品味。也幸好他没有立刻咽下。甫一入口，他便失去了意识，待回过神来，首先感受到直冲颅顶的异香，接着是远胜于火水的辛辣；寒流从黏膜扩散到四肢百骸，沁人心脾，又不知何时转化为一股暖意。他的嘴里还有什么柔软温热的东西……等他终于又能看清了，才发现钟离正搂着他的脖子，几乎半躺在他怀里。他们四唇相贴，比仙酿更加甘美的舌头在他口中搅动，催促他把残余的酒液渡给对方。

这亲密的举动很快转为一个真正的吻。彻底清醒之后，达达利亚意识到自己把钟离的束发扯开了。他以手作梳，有一下没一下地理着那头长发，尚且记得问一句：“先生忙完了吗？那杯是什么东西？”

钟离也不坐直，从下往上带着一点揶揄和无奈睨他。“忙完了。是公子现在喝不得的东西，我差点儿得赔至冬一个执行官。”

达达利亚没去探究其中深意，只在意前半句，甜甜地关心道：“那帝君大人累不累？”

帝君大人自然听得懂这称呼和语气是什么意思，一本正经回答：“从主观体验上说，都是精力和能力范围之内的工作。事务熟悉，偶有挑战。”

“佳节将至，说好休个长假，大人怎么还是如此辛劳。”异国武人装模作样地摇了摇头，“还是让我伺候您歇息吧，帝君。”

钟离在他一把扫掉桌上剩下的杯子前将它收了起来。

　

END

　

然后帝君大人在桌上和树上还有地上被伺候了小几个钟头。

https://www.youtube.com/watch?v=ZhIKtslU3TM OpenClassrooms : ChatGPT de A à Z : Le cours complet

https://www.youtube.com/watch?v=a8uoxN6_Zic Formation ULTIME ChatGPT 2025 (GRATUIT)

https://www.youtube.com/watch?v=MqdCmS7CRPQ Comment créer des GPTs sur ChatGPT ? (Tuto Complet)