Fecha actual Lun Jun 24, 2019 10:33 am

Implementar la Paginación, Espacios Virtuales Múltiples y Multitarea, y Encontrar un Primer Camino de una Aplicación Específica para Usar Genuinamente Esas Características

[html]Historial/Ciclos_de_Trabajo/Description.txt[/html]

Usuarios leyendo este tema: Ninguno

Implementar la Paginación, Espacios Virtuales Múltiples y Multitarea, y Encontrar un Primer Camino de una Aplicación Específica para Usar Genuinamente Esas Características

Notapor ~ » Mié Jun 14, 2017 7:15 am


Después de un ciclo de 2 meses, en el que logré reactivar fuertemente
mi nivel de sistemas operativos como para ahora poderlo mantener en desarrollo
a base de pruebas que poco a poco se agregarán a una base limpia a mi kernel,
empiezo este ciclo, en el que pienso agregar finalmente la capacidad real
de manejar de forma útil y depurada la paginación en mi sistema.

Este ciclo se puede considerar como la segunda etapa del ciclo anterior, ya
que voy a trabajar directamente con los resultados logrados en aquel, y
también a un nivel práctico mayor que el anterior. Después de este ciclo,
debería tener una base de sistema operativo más fuerte que la que alguna
vez hubiera logrado hasta ahora.



En este ciclo de trabajo tengo que lograr:


- Implementar la paginación x86 de 32 bits.

- Buscar la aplicación original de esta, e implementarla. Creo que dicha
  aplicación podría ser la carga y descarga dinámica de librerías a un sistema
  microscópico y modular, así que eso es lo que voy a implementar.

- Buscar el camino práctico y útil de por lo menos una aplicación representativa
  para la práctica que nos sirva de ejemplo o de base para un subsistema
  dinámico. Esa aplicación inicial podría ser implementar la carga y descarga
  de librerías en el kernel (programa LDLIB) y también en los programas.

- Con eso empezar a implementar los espacios virtuales independientes simultáneos
  y la multitarea.

- Exportar masivamente las funciones existentes en el sistema para poderlas usar
  todas en los programas, con lo que el sistema se comportaría como una prueba
  que podría cambiar en tiempo de ejecución.

- Darle estructura de DOS a nuestro sistema, capaz para 16, 32 y 64 bits, con
  servicios estándar y extendidos simultáneos.


El nuevo kernel también debería poder ser cargable desde MS-DOS/FreeDOS más allá
del primer Megabyte, usado principalmente e históricamente por el Modo Real,
y el entorno debería ser configurado tanto como se pueda mientras estemos en
DOS usando nuestro proyecto BOOTCFG para luego cargar el kernel (dos proyectos
separados).

El cargador del kernel a su vez desde DOS podría ser un programa de snippet
de nuestro proyecto LowEST. Así que tenemos 3 proyectos entre manos hasta ahora,
junto con x86 Portable, que están formando la base a pulir y con la cual jugar
para llevar a sus límites para aprender y hacer posible la implementación de
nuestro sistema operativo.

Si bien son proyectos separados casi de librería y de snippets de prueba
y ejemplo, tendremos que ponerlos todos juntos en un solo paquete si los
queremos distribuir como un sistema operativo.




Acostumbrate a hacer cosas repetitivas como esqueletos de programas, armándolos
manualmente para acostumbrarte y que después esa tarea fundamental, actualmente
tediosa, de hecho se haga más clara en tu mente, y así, aprovechar todo lo
repetitivo para acostumbrarnos a los niveles básicos y repetitivos.




Leyendo páginas de nuestra mente al saltarnos bloques enormes de ruido
de tamaño y resultado inútil conocido.....



armando bros




Es posible que me resulte mejor escribir en formato de HTML con solo texto
anidado con las etiquetas PRE cuando transcriba. Así avanzaré mucho más
rápido y las cosas serán legibles, todo será tan simple como texto plano
pero con capacidad de estilos.


Cuando tengas varia memorias que sientes que quieren estar presentes al mismo
tiempo, y para evitar conflictos de sobreescritura de una a otra, que una haga
que se te olvide otra, trata de no mover nada de tu entorno, profundiza en
la idea más inmediata, que más te interese, acuérdate bien y procesa la idea,
y luego el resto... así desharás los conflictos y tendrás una mente más limpia
a nivel ejecutable.

También srve ponerno a esquivar el ruido tan pronto aparezca, no antes,
sino que cuando aparezca hasta que se vaya, también leyendo cada página
de memoria y leyendo con saltarnos bloques de procesamiento de ruido.



No debe haber ningún intermedio entre las cosas que hacemos, ya que
las esperas en vez de pensar y esforzarnos solo en hacer todo en el
inmediato plazo, son enormes errores.


-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------
-------------------------------------------------------------------------



Para tener un nivel más práctico podemos contestar y desarrollar/resolver
las preguntas o frases que los libros normalmente tienen en la portada,
tratando de demostrar de qué nos hablarán. Si podemos completar esas
preguntas con respuestas usables en proyectos de nuestro nivel, conetados
con código fuente y aplicaciones reales, sabremos que estamos estudiando
bien.

Y podemos hacer lo mismo con el índice, y después con cada ejemplo o
concepto, no solo tratar de resolverlo por nosotros mismos usando Google
y nuestro propio conocimiento y creatividad actuales, y tal vez otros
libros (otro ultracomplemento), sino que llevando esos conceptos hacia
proyectos reales.

Tenemos que conectarlo a código y específicamente cómo implementarlo,
además de buscar aplicaciones reales o efectos como los que vemos en los
programas reales... eso lo que va a hacer es que entendamos lo que hay
en el código de los otros programas. También podemos usar nuestra propia
creatividad, cosas que siempre nos hemos preguntado hacer, pero cada cosa
que nos diga un libro ponernos a preguntar qué podemos hacer con cada
conocimiento o información, hay infinidad de cosas y en eso pondremos
a entender mejor el ecosistema existente de código para profundizar de
esa forma.

Pero SIEMPRE conectando cada concepto y pregunta a responder por nosotros
mismos y después viendo lo que tiene el libro, desde el punto de vista
de conectarlo con código real y aplicaciones reales, no quedarnos NUNCA
en el ejemplo del libro, solo usarlo como ejemplo línea por línea de cómo
usar diferentes funciones, pero nada más, hasta que también lo entendamos
a este de forma trivial, pero si no vamos hacia entender nada práctico,
no lograremos tener suficiente nivel como para que el libro se vuelva
trivial y aprovechable.

Así fue como aprendí Ensamblador, y otra técnica para aprender a leer código
de terceros y reusar funciones, aprender a extraerlas, querer aprender algo,
ver código que tenga elementos de lo que queremos hacer aunque sean varias
fuentes, agarrar el código por fragmentos para tener ejemplos de cómo usar
e interpretar los elementos de código, funciones, variables, objetos.....
y con eso rearmar la lógica de otro programa, usando los fragmentos aislados
que otros programs nos muestran cómo usar.




Si un programa se puede implementar de muchas formas diferentes, signfica
que no ha sido totalmente descompuesto en sus componentes lógicos más
finos como para hacerlo portable y que tenga que implementarse siempre
igual, así que eso es lo que tenemos que hacer para mejorarlo... podemos
valernos de escribir el código crudo como librería de aplicación sin
plataforma, y después agregársela, en Ensamblador x86 Portable, que como
sabemos, puede alcanzar todas las plataformas al tratarlo como código
compilable o interpretable.




Y recordemos que los libros están fundamentalmente desconectados de código
fuente real a menos que nos presenten y se basen totalmente en completar
un proyecto real mientras explican cómo, en qué secuencia jerárquica
se implementó realmente, así que vamos a tener que buscar un proyecto
real cuando leamos un libro, siempre la combinación de 2 cosas, el nivel
virtual o teórico (libro) y siempre el nivel físico (proyecto a entender
con ayuda del libro). Ahora solo necesitamos leer una y otra vez hasta
hallarle camino a cada detalle que queramos entender.





Quizás todo lo que se nos ocurre cuando leemos un libro es lo que los autores
no escribieron, así que deberíamos transcribir el libro, lo que vayamos leyendo,
y agregarle todo lo que se nos ocurra para que resulte en un libro verdaderamente
bueno que hasta nosotros podamos escalar.

Aunque claro que lo ideal es tener el libro original y la versión a la que le
le agregaremos más y más conceptos con solo que se nos vayan ocurriendo.



http://www.youtube.com/user/AltComp126
http://devel.archefire.org/forum/

Yo estoy subiendo muchos videos de programación para aprender a manejar los programas que ya existen y tecnología para aprender a hacer sistemas operativos.

Voy a pasar a avisarles de videos nuevos que haga, también quiero ayudar a que otros aprendan a programar desde la edad que quieran aprender, es algo que me costó mucho lograr a mí y que no aprendí bien hasta como a los 16 años.






Intel Galileo
Intel GaAlileo




Siempre tenemos que hacer videos justo cuando se nos ocurre cómo hacer algo,
cuando tenemos el impulso inicial máximo.






Sé explicar y entender formalmente tantas cosas como videos tengo en YouTube,
sobre todo videos propios, y sobre todo, videos altamente populares.












EOF
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2945
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Implementar la Paginación, Espacios Virtuales Múltiples y Multitarea, y Encontrar un Primer Camino de una Aplicación Específica para Usar Genuinamente Esas Características

Notapor ~ » Vie Jul 21, 2017 11:57 pm


- Hacer mapas de la anatomía de los programas.

- Hacer un mapa de los programas para explicar la jerarquía y anatomía funcional
  para después saber qué tenemos entre manos.

- Reimplementar en Ensamblador todo. Si estamos con la PC, deberíamos empezar siempre
  haciendo todo puramente en Ensamblador y solo después automatizar a lenguajes de más
  alto nivel.

- Tratar de usar funciones a las que no les hallemos sentido en este momento, en Ensamblador,
  y hacer programas de prueba de ellas. Aprender a hacer binarios crudos con GCC y también
  a traducir a Ensamblador.

- Escribir todo el código con funciones de depuración que impriman y también pidan entradas del
  programador de forma flexible de diferentes formas.

- Soltar poco a poco el código a medida que determinemos que está bien implementado paso a paso.

- No trabar la computadora con CLI, HLT sino que simplemente salir de la función ANTES de un
  punto crítico que pudiera hacer que se trabe o resetee de todas formas.

- Hablar constantemente de las ideas que tengo. Buscar la forma de hacer útil, realmente usable
  mi sistema para la gente que esté tratando de aprender como yo. Tengo que hacer más videos de
  programas interesantes, hasta portear los programas 

- Recorrer cada línea pensando cómo implementarla sin ver el código de su implementación.

- Usar JavaScript y documentación de tipo de la de PHP, de la del HTML Reference Library y
  de cosas de la PC clásica de los 80's, 90's y 2000's.

- Ser realmente concreto, dispositivo por dispositivo, pero empezando con la información más
  básica, puertos, comandos de lectura, escritura, regiones de memoria... y con los dispositivos
  más simples. Algoritmo por algoritmo.

- Escribir todo por defecto en CHM Emulators, TOCs, SourceDocs compatibles para leerse bajo DOS.
  Para eso tendré que arreglar el Xul Eval para que vuelva a funcionar.

- Todo el código con trucos de los kerneles anteriores puedo convertirlos truco por truco
  en programas de prueba aunque tengan cosas redundantes.

- Tratar el kernel como una librería con funciones genéricas de todo nivel, desde el más bajo.
  Así nos centraremos en agregarle poco a poco las cosas que necesitemos para llevar a cabo
  nuestro desarrollo orientado a aplicaciones, las cuales nos indicarán lo que necesitamos
  agregar al sistema para hacer que sea fácil.

- Todos los sistemas nos han demostrado que es mejor implementar todas las funciones usuales
  monolíticamente en el sistema en forma de librerías usables por el kernel y dinámicamente
  enlazadas a otros programas y tal vez librerías.

- La PC es como el juego de video más constructivo, y parece que todos los que hacen hardware
  y software privativo quisieran deshacerse de esta, de este constructivísimo y divertidísimo
  juego a favor de una plataforma sin estándar, solo hardware con drivers cerrados y acceso
  mínimo al sistema mediante UEFI.

- Funciones de Ensamblador minimalistas. Solo cambiar los bits que necesitaremos en una
  función, no todos los bits de un registro. Eso hará que podamos reusar los bits sin uso,
  probablemente los bits más altos, para otra cosa sin que cada función que escribamos los
  alteren innecesariamente.

- Llevar lo extraño a un nivel utilizable normalmente.

- Inicialmente hacer un sistema operativo que detecte las cosas cada vez que las necesite
  usar, o que tenga estructuras de datos cacheables, creables y usables por componente de
  sistema que le digan cómo acceder, por ejemplo, un disco.

  Si hay un programa que puede listar todos los discos en el sistema, pero el sistema no
  guarda esa configuración sino que tiene que detectarla cada vez que se inicia a decidir
  qué dispositivo y partición usar, entonces hacer que también sea seleccionable un disco
  por defecto de esa lista de discos y particiones reconocidas, por ejemplo, para cargar
  de forma confiable programas del disco duro.

- Buscar de forma MANUAL cada mensaje de OSDev.org y de la Wiki, y anotar/copiar cada
  mensaje que tenga información rara, correcta, que tenga la calidad cercana a la de
  los primeros años.

- El problema por el que me detengo a cada momento en cosas de nivel de sistema operativo
  es porque no tengo toda la información y código en un solo y único lugar, sino que tengo
  que esperar a buscar aquí y allá. Debería poner todo en un solo lugar y asegurarme de
  que lo que he logrado hasta ahora funcione sin errores a mi nivel máximo estable para
  aumentarlo, hacer más pruebas en base a este, y así poder mantenerme concentrado sin
  fallar tanto todo el tiempo que mis tiempos de espera entre avances sigan siendo de
  días.

* Hacer una lista de metas cortas concretísimas y simplísimas todos los días, para
  un mismo objetivo, tarea, etc...

- Demasiadas cosas automatizadas, pueden perdernos funcionalmente.
  Son más rápidas que nosotros, si las dejamos funcionando para algo
  que tenemos que evaluar pueden hacernos perder energía al tener que
  repetirlas si nos quedamos atrás y se nos olvidó detenerlas...
  Hacer las cosas manualmente y después automatizar para rendir más,
  pero no depender de eso en ningún caso.

  Nosotros somos los ejecutores a ganar automatismo más importantes,
  las computadoras o sistemas más importantes y complejos. Somos nosotros
  a nuestro máximo nivel quienes debemos estar a cargo, colectiva
  e individualmente, fuertes individualmente y en grupo por separado.

- La única que nos hace sentir cansados y con tedio
  es la lógica equivocada, de baja calidad, de cómo
  hacer las cosas, cómo pensar, cómo lograr avanzar.
  Así que cuando nos sintamos así, tenemos que usar
  nuestra mejor forma de hacer las cosas, meditar
  un rato en las metas simplísimas para el día actual,
  en encontrar el camino más alcanzable, barato e
  inmediatamente rentable en términos de logros inmediatos.

- Publicar TODOS los pequeños trucos y cosas que hagamos,
  hasta ideas iniciales brillantes, a OSDev.org. Como sabemos,
  esos pequeñísimos detalles, más que pasar discutiendo
  con trolles y preferencias de implementación, es lo que hace
  la diferencia crítica y destraba al entorno entero, así que
  destrabemos a OSDev.org y todos los que como yo quieren
  funcionar y aprender sin límite en el nivel de sistema operativos.
  Y ya teniendo muchísimos trucos descritos en formato de foro
  en un mismo usuario, en este caso el mío, voy a servir muchísimo,
  con el nivel de atención de OSDev.org u otro sitio similar,
  pero cada cosa que escriba no tiene que ser nunca mensajes
  descuidados contra troles, tienen que ser cosas que me han
  elevado al determinarlas.

- Ser ultraespecífico cuando preguntemos o contemos algo en OSDev.org
  y otros lugares, y ser claro que queremos que nos digan cómo
  hacer algo, buscar una forma o preguntar otra vez en el mismo
  tema de una forma que haga que nos hablen basados en su experiencia
  real, que es lo único que nos va a hacer ver a qué nivel
  funcionalmente accesible de su trabajo de desarrollo están
  todos los que nos contesten.

- No tenemos que autoengañarnos ni pretender.
  Para avanzar realmente, tenemos que formar un
  grupo de gente e información (digital, libros...)
  que realmente estén a nuestro mismo nivel, gente
  a la que podamos enseñarle cosas, y gente que pueda
  realmente enseñarnos cosas a nosotros, hablando
  a partir de la experiencia práctica que realmente
  han tenido, no tanto de teoría que se supone que
  tienen que saber manejar, o sino nunca vamos a
  empezar a crear una base de avance común que de verdad
  entendamos todos los de un mismo nivel para progresar
  desde ahí con ruido en forma de teoría buena.

- Cuando nos sentimos confundidos, con tedio, que no
  sabemos qué hacer, tenemos que ver TODO lo que nos
  rodea en la vida real, y darnos cuenta de que esa
  confusión se presta para que nos pongamos igual de
  complejos. Cualquier nivel confuso que nos ponga a
  jugar cualquier influencia, es porque podemos detectarlo,
  entenderlo y sacarle ventaja al ponernos a hacer cosas
  igual de difíciles en ese mismo momento.

  Sentiremos que el contexto es más normal y enorme,
  más ocioso que de costumbre, cuando estemos confundidos
  e inspeccionemos todo desde el punto de vista de un
  entorno que es de hecho infinito y sin tareas de
  desarrollo activdaas.

  También podríamos cuidarnos de ese evento y evitar
  degradarnos de nuestro alto nivel a cada rato
  si inspeccionamos siempre para ver que no esté
  tan genérico y ocioso, y si encontramos formas de
  llenar el ambiente, como por ejemplo subir videos,
  primero de cuando aprendimos algo, y después videos
  individuales de cómo hacer cosas en la práctica.

- Un foro se puede leer como un libro del que podemos
  sacar lo más completo y lo más genérico como 2 volúmenes
  separados a descargar toda la información presente en
  este, si empezamos a recorrer menaje por mensaje
  individualmente.

- Después deun tiempo de ver a nivel de lógica irreductible
  todo lo que hacemos, en formato de instrucciones lógicas
  tan breves y específicas como las del CPU x86, en TODO
  lo que hagamos, vamos a ganar proficiencia y velocidad
  en decidir qué hacer en la secuencia de cosas reales que
  nos rodean y que tenemos por hacer, igual que cuando
  estamos escribiendo sin errores y eficientemente, de la
  forma más breve, un programa en Ensamblador.

- Centrarnos solo en los archivos viejos, los mejores que
  tenemos, cuando hacíamos mejor todo, para que volvamos
  a ese nivel de tareas, igual con los sitios web y cosas
  que nos divierten. Así podemos dejar de lado los archivos
  más nuevos y de menos calidad. Necesitamos hacer esto
  todo el tiempo, aunque parezca redundante, pero esos
  archivos y su contenido, las tareas ahí, van a darnos
  la misma eficiencia original, porque es parte de su
  esencia.

- Para mantenernos jóvenes, inteligentes y dinámicos,
  podemos recomprobar si lo que hacemos está bien cada
  vez que lo hagamos, a medida que lo hacemos, en vez
  de depender de supuestas memorias de experiencia
  de cuando nos salió bien una vez. Así vamos a
  estar en lo que estamos en vez de dormirnos,
  desactivar el cerebro, y dejar de ver de verdad
  si estamos haciendo bien todo, recomprobando
  en cada momento.

- Ver la distancia entre lo que queremos, nosotros
  y la dificultad de cualquier tipo que nos separa.
  Entonces empezar a profundizar mentalmente dirigiendo
  el flujo de pensamientos, energía y el o los pensamientos
  o ideas principales a dirigir nuestras acciones de
  trabajo.

- Portar una frase útil como "abandonware source code"
  a cada pensamiento. O portar una tarea como recordar los
  comandos a implementar. Portarlos en cada pensamiento
  ya que cada pensamiento provoca un cambio en nuestra
  conciencia, aunque sea menor, pero si hacemos eso
  vamos a terminar por sobrepasar cualquier cosa que
  nos esté afectando en eso estados mentales y zones del
  del cerebro aunque no lo notemos.

  Cualquier pensamiento que no sea ese, sobreescribirle,
  incluirle el pensamiento, el contenido que queremos,
  para que esté presente en ese nivel mental, en esa
  zona del cerebro, en ese pensamiento. Es igual que
  con la paginación x86, hacer que nuestro pensamiento
  que queremos mantener esté presente en los espacios
  privados o "virtuales" de cada pensamiento hasta que
  este sea accesible desde todos los demás pensamientos
  que se nos ocurran.

  Así este va a salirnos sea lo que sea que pensemos,
  y no se nos va a olvidar... vamos a poder darle
  continuidad, especialmente si sobreescribimos el
  tedio, el cansancio y cualquier CUALQUIER otra
  distracción, molestia, lo que sea que pensemos o
  percibamos.

  Así llegaremos a tomar el control de nuestra mente
  aunque otros pensamientos traten de cambiar nuestro
  contexto virtual mental mayor. Vamos a ser nosotros
  los que decidamos en qué va a estar nuestra energía
  mental sin cansarnos, igual que con la paginación,
  solo tenemos que hacer que una frase repetitiva
  se copie en cada pensamiento que se nos pueda ocurrir,
  para que esta sirva como un acceso a nuestra conciencia
  de desarrollo sea cual sea el nivel mental en el que
  nos lleve cualquier pensamiento.

  Sobreescribir hasta entornos mentales genéricos
  para retomar el control.

  Así se nos podrá seguir ocurriendo de todo hasta sin
  hacer realmente esfuerzo, solo copiar automáticamente
  la página o engranaje de una idea o tarea a ejecutar
  a todos los demás pensamientos de nuestra mente,
  A TODOS, para que el pensamiento que queremos se
  convierta en el kernel principal que dirigirá
  nuestras acciones, no el estar errantes...


  Quizás podríamos hasta escribir todo el entendimiento
  de un sistema operativo si portamos cada frase de
  código y libros a todos los niveles y pensamientos
  normales de nuestra mente... solo necesitamos mantener
  el tráfico de los datos buenos que queremos que se
  conviertan en parte de nuestro kernel consciente,
  y le ganaremos a cualquier otra cosa que nos haga
  débiles sin esa técnica ni ese tráfico de datos
  buenos.

  Para traficar esos datos, usar TODO lo que necesitemos
  hasta que ganemos soltura... realmente llegará un momento
  que sentiremos ligereza repentina sincera por sí misma,
  justo cuando escribamos todos los puntos de pensamientos
  que vengan del ruido, preocupaciones, o lo que sea, ahora
  en todos estará presente lo que queramos hacer, será
  accesible en todas direcciones, así que sea lo que sea
  que pensemos, nos mantendremos a nivel funcional
  exactamente como queremos.....


  Tan pronto como obtengamos esa ligereza, en tan poco
  tiempo como 1 hora o menos, podremos alcanzar nuestro
  máximo nivel de eficiencia que no habíamos tenido
  hasta en décadas tal vez...

  No importa que se nos olviden o haya otras ideas
  buenas, el mantener una idea ejecutable como la
  central en todos los contextos de cada pensamiento
  posible, cada neurona, red neuronal, célula e
  inteligencia virtualmente creada en nuestra mente,
  hará que el resto de ideas también se mantengan
  mucho más fácil.


  Podemos hasta hacer eso con gente que queremos encender
  en algo, insistir en un único tema principal hasta que
  este, el código o resultados producidos, nosotros y
  ellos lo entendamos por completo, estemos totalmente
  familiarizados y veamos cómo desaparece el ruido
  y el trolleo en base a este.

  Encontrarnos mutuamente nosotros y los pensamientos,
  neuronas, etc. Así vamos a hacer que todos nuestros
  recursos puedan encontrarnos a nosotros, no perderse
  con ponerle atención al ruido en vez de nosotros, y
  nosotros vamos a poder tratar también de encontrar
  dónde están nuestros recursos, pensamientos, etc.,
  para dejar cada vez más fuera el ruido de nuestros
  procesos.

  Si tenemos la intención de hacer algo en sí,
  de entrar en acción, aunque inicialmente no nos cueste
  podemos copiar esa intención, su contexto, y su
  acceso a la energía a cada pensamiento que tengamos.
  Así sea cual sea el estado mental o nivel de conciencia
  en el que estemos, tendremos el mismo entusiasmo y
  cero tedio, y podremos comparar y comprobar de forma
  objetiva que no estamos perdiendo el tiempo, al tener
  lo que queremos hacer y pensamientos inútiles en los
  mismos espacios virtuales para todo lo que se nos pueda
  ocurrir, así que terminaremos profundizando en lo que
  queremos con el peso acumulado de todo lo que queremos
  hacer... solo tenemos que hacer esto todo el tiempo,
  tanto como parte de nuestro desarrollo de sistemas
  operativos....

  Hasta para estudiar cosas normales como matemática puede
  servirnos, para profundizar y hacer que todos los
  contextos de procesos de pensamientos, de todo lo que
  se nos ocurra, esté enterado de que queremos aprender
  matemática.

  Antes y en vez de dar paso a cosas que sabemos que
  son conflictivas sin apornarnos nada de lo que necesitamos,
  debemos copiar el contexto funcional de lo que queremos
  realmente hacer en el contexto de esas otras intenciones
  de acciones errantes.

- Ponernos a escribir de forma clara en OSDev como si
  estuviéramos haciendo un pprograma, porque realmente
  es así. Estamos subiendo las definiciones de trucos
  únicos igual que los del resto que nuestra mente
  contiene para implementar tareas de sistema operativo,
  así que será mejor que subamos algo bueno al servidor
  de alguien que muchos acceden.

- Para avanzar, escribir con etiquetas PRE nuestros SourceDocs
  nuevos que vayamos haciendo, así será tan rápido como
  simplemente escribir en un archivo de texto, pero con un
  poco más de estilos e hipervínculos.

  Esto también nos dará la oportunidad de poder implementar
  todo en forma de instrucciones del CPU, concisas y claras.
  Y si insistimos en cada uno de nuestros temas hasta llenarlo
  de TODOS los detalles y código de los que pensamos agregar
  a nuestro código, terminaremos encendiendo minuciosamente
  a todos, todos sabrán cómo trabajamos, y nos tendrán cada vez
  más paciencia, consideración, atención, interés, cooperación,
  y nos dejarán volver repetidamente a nuestros temas, muchas
  veces para ayudar.

  Recordemos que lo que pongamos de código sobre todo, llega a
  ser parte del código del sistema operativo común
  de OSDev.org, así que realmente es como si estuviéramos
  contribuyendo cambios a un kernel y otros proyectos.
  Hay que hacerlo para avanzar todos en serio, de verdad,
  como sé que quiere OSDev.org como en un principio.

- El código base específico para los trucos
  de la PC es pequeño relativamente, pero
  extremadamente vital tenerlo, que no se
  pierda en Internet.

- Use wide variables for BIOS and
  DOS-like calls, and structures
  containing all registers, when
  calling your own BIOS/DOS-like
  services. In this way they will
  remain backwards-compatible, but
  taken to the full width of the CPU
  for every parameter.

  Those services worked well as
  non-multitasking, so it will work
  well since it will be more multitasking,
  safe-threading than the original
  BIOS.


  We will probably be also better off
  defining our wideword-sized BIOS
  Data Area, or probably containing
  64-bit or 80-bit FPU integer or
  floating point data.


- Así se trabaja en el desarrollo de software
  pesado. Un único archivo que parece basura donde
  se contiene toda la información y código de tantas
  sesiones como podamos para evitar cansarnos creando
  archivo tras archivo, y poco a poco extraemos la
  información generada a sus lugares finales de forma
  ordenada desde ese archivo, como una pizarra de
  pruebas.

- Siempre empezar poniendo solo la parte inicial
  de lo que hemos hecho en un foro, que va a tener
  el mismo efecto de preguntar "¿ya le han puesto
  alguna seña a algún papel que están escribiendo
  o un separador de hojas a un libro para indicar
  dónde empieza algo? Entonces así necesitamos
  ponerle señas a un programa para que el sistema
  sepa qué direcciones de qué instrucciones reubicar
  a cualquier punto de la memoria".

  También va a quedar mejorado como una clase donde
  una secuencia más limpia y más fácil de obtener,
  hecha entre todos, se puede terminar desarrollando.

- El código de cosas como timers es de las cosas que
  más código de ensamblador de mayor nivel me hace
  escribir.

- Usar el cuerpo, los músculos, incansablemente aunque
  tengamos que trabajar con el cerebro apagado.
  La intención es no dejar de tener un flujo de
  actividades buenas para desarrollar cosas.

- Tratar de igualar lo incansable del corazón
  al movernos. Sabemos que se puede hacer de una
  forma rítmica, apretada, sin interrupción,
  con presión y descansos en fracciones de segundos,
  con movimientos a escala no mayores que los que
  hace el corazón. Así probablemente podríamos
  aguantar un esfuerzo sin fin.

- Tirar las uñas del final de un ciclo de trabajo
  en un lugar especial específico tiene un gran
  efecto psicológico.

- Solo unos pocos ticks de calibración oyendo el
  silencio aparente y escribiéndolo en TODOS los
  pensamientos bastan para deshacerse de la confusión,
  como si fuera un retraso mental reversible,
  donde nos quedamos atrás de nuestros pensamientos
  por distracciones.

- Hacer un súper reloj basado en electrones, pulsos,
  neurotransmisores y circulación individuales,
  cada vez que actúan o son generados es un pulso
  de un reloj. Usar eso para deshacer la distracción.

- Parece que todas las actividades humanas y animales,
  de la vida completa, describen el código genético
  y otras cosas relacionadas que tienen que ver con
  quienes las usan  les gustan.

- Describir los programas que queremos hacer en
  términos baratos, verbales, humanos, y desde ahí
  ver cómo se corresponden las instrucciones, algoritmos
  y acciones normale con la implementación.

- Hay que dar muchas vueltas en un programa para entender
  que no todo es parte del algoritmo, sino que hay partes
  que son para sostener el programa en la máquina, pero
  igual que los trucos que escribía cuando estaba chiquito,
  esas vueltas extra para hacer que funcione realmente el
  programa son realmente también parte del algoritmo, así
  que tenemos que explicarlo incluyendo esos detalles
  de tolerancia, esperas, casos especiales, vueltas aparentemente
  de lenguajes de programación, pero que realmente son parte
  de la lógica.

- Solo vemos un pedacito de código a la vez para un truco o
  función, así que eso es todo lo que necesitamos separar,
  en fragmentos separados de componentes, ese código para luego
  integrarlo de cualquier forma arbitraria. No necesita estar
  en un mismo archivo o fragmento, sino que podemos separarlo.

- Elevarse en un punto mental para estar como queremos.

- Parece que necesito ser protagonista en lo que hago,
  que me pongan atención haciendo yo cosas que sirvan
  en general, para poder progresar. Necesito que
  me ayuden o que no me interrumpan.

- Creo que voy a tener que trabajar en base a la energía
  débil y fragmentada que tengo, en base a acumular resultados
  hasta poco a poco tener algo que mostrar. Así por lo menos
  voy a tener resultados, voy a tener cosas difíciles de
  lograr, y aunque logre muy poquito, va a ser algo que
  después alguien más podria usar para avanzar, pero ya que
  va a ser un trabajo hecho al máximo, no va a sermpe os
  perder el tiempo por poco o mucho que haga y me tarde.

- Una de las características de JavaScript y otros
  lenguajes interpretados como PHP, pero sobre todo JavaScript,
  es que ya tienen absolutamente todas sus funciones
  incluidas sin que se lo pidamos, así que lo que vamos
  aprendiendo de JavScript es como si lo incluyéramos,
  y fuéramos acumulándolo, y ya que no se nos pierden
  funciones que no conocemos porque ya están incluidas,
  las referencias abundan para todas las funciones. Así que
  si para un programa agrego TODAS las funciones que puede
  tener, tendré el mismo nivel de accesibilidad, en un
  esqueleto de Enamblador, C, Java... que primero incluya
  TODO lo que puedan para un sustema operativo y librerías
  de código abierto y de terceros, y TODAS las librerías
  del lenguaje que usan y de otros, y después haga uso
  transparente de cualquier función... eso hará que las
  referencias sean más entendibles, pero debemos tener
  un esqueleto que acumulativamente incluya más y más
  funciones.

- Expandir mi conocimiento de los sitios de Internet con
  interacción en tiempo real.

- Creo que debería eliminar todos los sitios que no
  sean del 2005 o antes de mis visitas regulares,
  todas las acciones, ideas, preocupaciones, y agregar
  otra vez todos los sitios que me servían en esa época,
  tareas, diversión, para nivelar la nulidad y contra
  la negatividad del vacío actual. Es una base que
  realmente tengo que asegurarme de conservar.

- Las horas no son nada, para hacer programas que realmente
  sean útiles y que hagan cosas nuevas para nosotros,
  que no habíamos implementado antes, SIEMPRE nos tardaremos
  varias horas a menos que estemos a nuestro máximo
  absoluto en todos los aspectos. Así que siempre tendremos
  que preocuparnos simplemente en adentrarnos al máximo en
  una tarea, sentir que estamos profundizando muchísimo
  mentalmente, que es lo que realmente importa, profundizar
  para curar nuestra mente, cuerpo, y para mantenernos
  con la aceleración y estado mental que nos permita
  maximizarnos y progresar nosotros y nuestros proyectos.

- Hay que hacer todo lo posible para hacer un espejo
  de nosotros mismos, de que nuestra secuencia de acciones
  se repita y se entienda para aprender y contribuir sin
  nosotros estar presentes. Hasta mi amiga gata lo que hizo
  es más que un espejo.

- Hay que determinar el framework de optimización, multiplexación
  y de estructura de Windows, para tener una idea de cómo implementar
  todas esas cosas y funciones de forma unificada o ramificada pero
  transparente.

- Hacer un resource compiler, compilador de recursos,
  en JavaScript, para importes, exportes, diálogos, etc...,
  que nos dé el código en Ensamblador para generar valores binarios
  para que cualquier programa los pueda usar.

- De hecho, concentrarnos en implementar todo tipo de aplicaciones
  en HTLML5 y JavScript de bajo nivel altamente optimizados y
  explicados para avanzar rápido. Esos programas en JavaScript
  también son parte de nuestro sistema operativo y base de código,
  codebase.

- Una vez que encontramos una tarea, que nos bloqueamos y que
  agarramos impulso, no debemos desbloquearnos nunca de esa tarea,
  solo hasta encontrar otra tarea que nos bloquee de forma igual
  de intensa.

  Mientras tanto, tenemos que seguir bloqueados, haciendo la tarea
  bloqueante que encontramos repetitivamente hasta que ya no se nos
  ocurra nada más que hacer y perdamos impulso naturalmente, sin
  siquiera intentarlo nosotros. Con lo aprendido, podremos avanzar
  en otros aspectos y después seguir avanzando en la tarea que acabamos
  de estar tratando, una vez que se nos ocurra qué más hacer y lo podamos
  hacer masivo al volver a bloquearnos mientras:

  - Tengamos el impulso.
  - No aparezca otra tarea para cambiar de ambiente sin pérdida de tiempo
    ni distracción entre las dos tareas, cuando hagamos cambio de tareas.

  Solo hay que ver cómo empecé haciendo un esqueleto de PE EXE
  muy simple, y ahora estoy logrando exactamente lo que quería,
  que era tener a la mano la WinAPI completa con solo incluir
  <windows.h>, o en este caso, importar todas las DLLs estándar
  y todas las funciones básicas retrocompatibles a todas las versiones
  de Windows, para poder hacer programas de Windows tan fácil como
  si fuera scripting de JavaScript.

- SIEMPRE tengo que hacer funciones de envoltura, Wrappers, que deben
  tener SIEMPRE la estructura exacta que yo quiero en todo momento.
  Con estas podré envolver las funciones disponibles en cualquier sistema
  operativo o entorno de programación y ejecución. Sin estas mis programas
  no sobrevivirán lo suficiente como para perdurar, ya que no tendré la
  capa de funciones propias que me permitan reimplementar dichas funciones
  de cualquier forma, 100% por mí o usando otras funciones disponibles,
  sin que sea siquiera notorio en el programa al nivel más alto, general
  y portable de la aplicación.

  Así que esta es la forma en la que puedo darle a todo la estructura que
  yo quiero, usar las cosas como me gusta implementarlas como envolturas/wrappers
  de las funciones o algoritmos disponibles. Así hasta puedo reimplementar mi
  sistema operativo como una aplicación regular, de ida y vuelta, usando
  mis APIs y lo que aprenda de otros sistemas para hacer que crezcan tanto
  mi sistema en forma de kernel propio como de aplicación de prueba porteada
  a otros sistemas operativos.

  Como coLinux nos demuestra, un sistema operativo realmente se puede portear
  como una aplicación normal, pero la parte más estándar, que más nos gusta y
  que más natural nos salga tiene que ser la principal que nos dé paso al
  resto de funciones sin perder portabilidad, para conectar nuestras habilidades,
  inteligencia y caracteres lógicos personales a lo que ya existe, y así aumentar
  nuestro éxito en implementar programas.

- Compaginar SIEMPRE el sistema operativo y programas que estamos haciendo,
  en modo wrapper, para ver más fácilmente cuánto sentido tiene lo que estamos
  haciendo y en dónde deberían caer las características que no hemos logrado
  cargar hasta ahora.

- Hay que programar todo en Ensamblador Portable, con wrappers, algoritmos base
  y no dejarnos engañar con falsas soluciones. Seguramente Windows está implementado
  básicamente en Ensamblador por cada arquitectura (podría ser otra forma de
  proteger su código, probablemente sean todos los trucos de Programmer's Heaven, etc.,
  además de tener todo el apoyo abierto de la industria), así que también necesitamos
  abrir todo lo que está a nuestra disposición al más bajo y completo nivel.

  Hasta para reimplementar Linux tenemos que usarlo, ver cómo funciona, y tratar,
  además de traducirlo a código de Ensamblador.

- Aprender a hacer VxDs, empezando por la de VBE 2/3, traducirla a Ensamblador Portable,
  aprender su formato de archivo, y completar lo que no sepamos inspeccionando
  la estructura de la VxD compilada en sí.

- Ver los importes de las DLLs y programas viejos, aprender a expandir los
  Programas de Win16 como en memoria, compilarlos, ensamblarlos, tener un esqueleto
  de PE EXE, y tratar de importar todas esas DLLs con sus funciones 100% estándar
  presentes en todos los Windows para tratar de completar al máximo la WinAPI
  y librerías comunes y universalmente presentes en la plataforma Windows.

- Instalar Borland C 5.01 en la Thinkpad 390X para aprender a importar las DLLs de
  OWL, solo para ver cómo son.

- La intención es tener un flujo interminable de código fuente donde no
  se distinga dónde empieza o termina, y poder agarrar un poco y empacarlo
  en aplicaciones. Me ha ayudado considerar y saber que necesito aprenderme
  y estudiar todos los programas, código, libros, referencias, etc., existentes,
  para poder entender y encontrar los trucos al saber dónde están, al tener
  todo el código completo y funcional en nuestra memoria y mente creativa,
  ejecutable.

- Cuando se haga trivial hacer los programas de Windows
  de cualquier tutorial, libro, o reimplementar existentes
  en Ensamblador.







































































Veo que hay una técnica especial en la que tengo
que considerar TODO lo que existe, TODo, y también
por ejemplo todos los programas de código abierto y
cerrado, considerar cómo habrían sido hechos, cómo
será su código, sus trucos, parecidos con otros,
información disponible de estos, todo su código,
y tratar de mantener un ambiente infinito con todos
ellos en mi mente. Entonces tengo que tratar de
meterme todo eso en la cabeza, tengo que tratar de
estudiarlo de forma simultánea hasta a nivel neuronal,
tratar de leer detalles y su información en cuestión
de forma mental, ambiental, universal, con mi
sensibilidad, y mantenerme estudiando sin descargar
nada de lo que existe de mi mente, para que cuando
encuentre cualquier cosa me resulte provechosa.

Igualmente, tengo que considerar el implementar
y crear librerías humanamente ejecutables, implementar
todo de una vez mentalmente, para así sentir que
no estoy perdiendo el tiempo y avanzar hasta donde
entienda cada camino de cada tarea.










































- Paletas de funciones implementadas, errores,
  límites, valores producidos, etc...

- Enseñar Ensamblador al programar siempre con
  ese estilo de programación, usando funciones
  que implementen instrucciones, registros, etc.
  De esa forma podemos agregar lo que hacen todos
  los procesadores, y que se entienda cómo se puede
  implementar en pequeños pasos todo.

- En un sistema operativo lo primero más importante
  es lo que aparece en la pantalla, así que tenemos
  que volvernos expertos en mostrar todo lo que hay
  ahí, también hacer un programa que muestre los
  valores en multihilera de TODAS las variables, en
  modo gráfico y modo texto para practicar esas
  funciones.

- Pasos para implementar soporte para cambio de
  discos, discos IDE de 28 y 48 bits con PIO,
  particiones y soporte completo para FAT32 LBA
  y funciones de sistema de archivo asociadas.


- Tengo que basar todo en acciones,
  en alcanzar un estado práctico de algo en base
  a sentir y buscar el camino funcional, no en base
  a un modo verbal ni mentalmente, ya que este viene
  cuando un contenido genuinamente es verbal, pero sino,
  voy a tener que basarlo en observar y entender
  repetidamente.

- Custudiar todo a todos los niveles como mi amiga
  gata, y englobar a todo y todos los que me interesan,
  y también nuestras mejores épocas, en esa custodia.
  Se siente que tenemos la libertad de hacer absolutamente
  todo cuando estamos ahí, que no tenemos límite de tiempo
  ni de recursos.

- Los carros y otras máquinas grandes siempre son un
  desgaste si estamos cerca de ellas, así que lo mejor
  es protegernos cada vez que estemos ahí, o de una u otra
  forma vamos a recibir algún daño.

- Hay una parte de mi salud, actualmente la mayoría,
  que yo tengo que activar y hacer que el cuerpo se cura
  y que, cuando no hago el esfuerzo, simplemente dejo de
  curarme como yo quisiera.

- Guardar y restausar toda la configuración
  antes y después de entrar y terminar un
  programa, en el kernel, y en programas
  monotarea anidados hijo, para que cada
  subporgrama pueda tener su propia
  configuración y uso de hardware sin la
  posibilidad de destruír la ejecución
  del kernel ya que dicha configuración
  será guardada y restaurada, igual que
  los registros del CPU. Para la
  máquina no habrá diferencia alguna.

- Exportar TODAS las funciones del kernel
  y variables de tiempo de ejecución para
  darle potencia máxima

- Implementar el demo de ventanas de
  Alexei Frounze, y X, en Ensamblador.
  Igual la versión inicial de Linux,
  de Minix, de VisOpSys....

- Convertir a VisOpSys en un módulo
  de Ensamblador para LowEST, igual
  que MenuetOS y a FreeDOS, y a
  ReactOS y Wine, y después partes
  de Linux y BSD... terminaremos
  entendiendo todo ese código y los
  demos de Programmer's Heaven,
  todo simultáneo y según nos divierta.

- Agregar Bochs en Ensamblador con red,
  sonido, drivers de video, para poder
  correr otros sistemas sin salirnos del
  nuestro, y de hecho convertir cualquier
  programa que usemos a Ensamblador.

Quebrar la burocracia de la complejidad
con un estudio e implementación verboso.
Alcanzaremos así las funciones de la
computadora que normalmente deberían
ser accesibles con simplicidad en
estructuras y puertos simples, con
explicación fácil, no solo un nivel
derramado, pero que es algo que
podemos empacar y convertir en una
librería fácil de alcanzar.



- Copiar código y directorios en masa para un
  tema. Después, examinar todo y todo lo que
  no sea sobre un tema, por ejemplo, discos ATA,
  borrarlo para ahorrar espacio y tener referencias
  cada vez más concisas.

- Agregar soporte para SATA para poder leer
  discos duros nuevos mayormente con NTFS
  y sistemas de archivos de Linux, etc...
  y así hacer que nuestro sistema se extienda
  de forma práctica y útil, empezando para nosotros.

- Agregar soporte para Unicode, UTF-8, TTF,
  APIs de HTML/HTML5/JavaScript.

- Portear el código de Z26 para DOS a nuestro
  sistema operativo, jugar X-0 de 4 tableros y otros
  juegos para ver cómo vamos..... tratar de activar
  la Sound Blaster nativ o emulada, tratar de usarla
  para ver si se puede.

- ¿Y la IRQ de los discos duros?

- Tal vez tratar de portear CrystalDiskInfo

- Rehacer los libros de Ensamblador de Charte Ojeda
  en uno solo y totalmente a mano, en Ensamblador,
  solo con NASM. Cuando lo logremos, podremos decir
  que hemos logrado subir más de ese nivel...

- Portear XMMS, Linux From Scratch como subprograma....

- Niveles y fechas para darle números de versión
  a programas, que se entiendan en dificultad de
  estudio y complejidad en la capacidad de manejo
  de tareas.

- Incluir hasta las funciones de Firefox y SQLite3
  en la librería loca del kernel de LowEST para
  experimentar con los resultados al más bajo y
  portable nivel.

- Comparar el código de todas las versiones del
  kernel de Linux y otros sistemas sobre un único
  tema, como los discos duros IDE, y otros temas,
  para tratar de entender de forma fácil y entendible
  absolutamente todo lo que han aprendido, hecho de
  trucos y logrado para hacerlo posible y cada vez mejor.

- Notepad++ en Ensamblador...

- Tratar de escoger un sistema simple existente con ventanas,
  como Menuet o VisOpSys, y agregar esos programas ahí.

- Estudiar los libros de FYSOS para obtener todas las
  ideas que tienen rápido, y agregarlas a nuestra base
  de código, en la librería loca, una forma realmente transparente
  en la que nadie podrá reclamar que estamos usando su código.

- Reactivar el servidor de MJPG, y mover a otro disco
  los archivos de contraseñas a otro disco para poder
  ver el contenido entero desde Internet sin peligro...

- Necesito tener redes os máximo nivel

- Si un animal está en una casa humana, podemos
  tratarlo como humano cuando lo lavamos, ponemos
  en un lugar tibio para dormir y estar, aunque
  el baño haga que funcione menos o no esté
  igual que en la naturaleza el plumaje o pelo,
  aunque deberíamos buscar una forma de corregir
  eso también. Esto es especialmente si el animal
  tiene algún problema o si simplemente es peligroso
  que esté afuera y que le resulte mejor vivir como
  nosotros.

* Si detecto mi cansancio, si trato de detener
  el descanso, siento que hago que se acumule
  naturalmente y llega a permearme por su cuenta.
  Pero tengo que mantener con fuerza parecida
  al enojo, pero concentrada, calmada y natural,
  sin enojo realmente, mi descanso.
  Se pudede hacer con cualquier otro aspecto,
  idea, lo que sea, hasta sueños, cosas impensadas.....

- Dump crudo y con interpretación de significado
  de campos.

- Convertir todo en iconos, hasta los países,
  lugares de estudio, etc., para digitalizarlos
  o convertirlos en programas de información
  que correspondan a lo que hacen.

- BASARNOS OTRA VEZ EN BUSCAR LAS COSAS MÁS DIFÍCILES
  DE ENCONTRAR Y QUE MÁS NOS PUEDAN ENSEÑAR... ASÍ PODREMOS
  POTENCIAR TODO LO QUE HAGAMOS.

- Aprender a escarbar el código al imaginarnos todo
  para lo que podría servirnos posiblemente una función
  hasta que el que se nos ocurran cosas se vuelva una
  tarea usual.

- Hacer lo que pensemos en forma de videos. Hacer una caché
  de videos crudos con nombre, que iremos editando y
  subiendo poco a poco, guardados en un lugar central.

- HTML5 y Ensamblador con hardware crudo bajo DOS o nuestro
  propio kernel son extremadamente parecidos.

- La multitarea puede servirnos para poner cosas que realmente 
  se tardan demasiado en sus propias tareas.

  El código que está preparado para la multitarea, paginación
  y diferentes niveles de privilegio podría verse raro, pero
  si sabemos que eso es lo que tiene que ver con que se vea así,
  podemos entrar en esa mentalidad y ver que el código está
  inusualmente fragmentado comparado al de otras épocas.

  También es posible que las optimizaciones tengan precisamente
  que ver con esta repartición de tareas, tal vez usando instrucciones
  que se afectan al mínimo en la caché y que reusan resultados
  entre sí.

  Podemos implementar un kernel para el Ring 0 y otro kernel para
  el Ring 3, que ambos estén en sus propias tareas, que tengan
  acceso sin restricción entre ellos, mapeados en Ring 0 y 3
  a la vez, y que después den acceso extremadamente eficiente
  a los programas de su nivel. Esto hará que necesitemos cambiar
  entre Ring 0 y 3 muchísimo menos solo para llamar al sistema ya
  que tendremos parte del kernel en Ring 0 y parte en Ring 3,
  ambos con acceso directo entre sí.

  De todas maneras hasta los drivers terminan teniendo acceso
  al sistema de esta forma y también a las aplicaciones, parte y parte,
  así que tiene sentido totalmente que el kernel mismo tenga 2
  partes y que pueda llamarse y manipularse entre sí, aunque sea
  la parte del kernel de Ring 3, sin restricciones de por medio.

  También podríamos hacer que el sistema sea capaz de correr totalmente
  en Ring 0, como opción activable/desactivable, y también sin
  paginación ni multitareas. Eso hará que el código sea más flexible
  y adaptado a diferentes situaciones y necesidades de desarrollo
  de bajo nivel directamente sin más herramientas.


- Función para obtener el tamaño de clúster y de sector donde está
  un archivo, para planear leer solo parte del clúster o reservar
  un tamaño suficiente para sectores de forma totalmente óptima
  y así aumentar el tiempo de accesos y mantener una caché
  del tamaño correspondiente, no menor, para acceso rápido y
  bien cacheado que permita minimizar el tamaño de la memoria.

- Un programa debe poder tener la libertad de decidir exactamente
  cuánta RAM y disco duro usar como memoria para poder
  ajustarse (tune) adecuadamente, hasta encontrar el punto
  óptimo en el que sea igual de rápido sin desperdiciar demasiada
  RAM, solo la ventana para la ejecución actual y una caché razonable
  de acceso para agilizar, pero no más.

- Hay un límite en la cantidad de RAM y CPU que nos puede resultar
  beneficiosa, ya que hay un límite de procesos concurrentes que
  pueden correr de forma eficiente alcanzando todos esos recursos.

  Además de eso, las cantidad máxima de tareas, CPU y RAM usadas
  en un momento están dadas por lo que nosotros personalmente sabemos hacer
  a nivel de implementar un sistema operativo y hardware desde cero,
  así que si no podemos usar más que un nivel dado de hardware, estaremos
  desperdiciando esos recursos y convirtiéndolos en cosas misceláneas,
  sin nada especial que ofrecer, cosas no estándar,
  hasta no serían más que basura con forma, o simplemente
  materiales con estructura funcional que no nos servirán de nada
  para desarrollarnos.




- Las hormigas progeten los árboles.

















2017-07-18 (Martes)
---------------------------------------


- Una de las cosas que podemos hacer para sentir
  mucho menos tedio cuando trabajamos es que lo que
  hagamos lo deberíamos considerar como una adición
  al código de nuestros proyectos, a nuestra
  base de código, a nuestro repositorio de código
  y de información, y deberíamos tener la actitud de
  empezar agregando muchísimas utilerías pequeñas
  de código y después estudiar cómo integrarlas y
  derivar código propio, ponernos a trabajar en
  construir más estructura para nuestras herramientas
  e interfaz entre nosotros, nuestro cerebro y la
  computadora. De esa forma siempre vamos a poder
  profundizar al máximo de inmediato en vez de perder
  la perspectiva y sufrir tedio.

  También deberíamos considerarlo una adición
  a nosotros mismos y a la forma de hacer las
  cosas, y al tipo de época que más nos gusta
  vivir, así que ahora es cuando lograr eso.

  Así que todo lo que hagamos tenemos que recubrirlo
  con esta actitud para aprovecharlo sin excepción.



- Que nuestro sistema tenga acceso por defecto a
  muchísimos libros viejos como parte de la ayuda.



- Lo más crítico en un sistema y que tenemos que
  hacer funcionar a como dé lugar es
  la facilidad de arrancar el sistema
  sin cambiar nada, el CPU,
  la memoria, la pantalla, el teclado/mouse,
  el disco, el sonido, la red, las herramientas,
  la simultaneidad, la variedad, y
  la compatibilidad con drivers y programas
  en todos los formatos. Si nos quedamos
  trabajando solo en esas cosas indistintamente,
  tendremos un sistema operativo inmediatamente usable.

  También el timer, el controlador de interrupciones
  y los periféricos en general, además de la
  portabilidad del código y las características
  básicas del CPU.

  Lo que interesa es que la capa más superficial
  y accesible de la API de alto y bajo nivel tenga
  siempre la misma estructura. Así podremos cambiar
  la estructura interna del sistema sin perder la
  funcionalidad que ya hemos ganado.




- Aprender a reusar cualquier función, línea de código
  o porción que veamos, e imaginarnos cómo podríamos
  usarla. Cuando se nos ocurra, podemos usarla en algo
  que estemos haciendo..... así me pasaba frecuentemente
  en el ITCA allá en el el 2001.


- Mantener una caché de toda la multimedia descomprimida
  y otros archivos procesados. De esta forma, no desperdiciaremos
  el CPU ni memoria, pero necesitaremos más almacenamiento
  en disco para dicha caché, como un espejo del sistema
  de archivos, pero conteniendo archivos postprocesados
  total o parcialmente, dependiendo de la configuración
  y el espacio en disco. Lo bueno es que para archivos
  frecuentes la caché estará más disponible así que
  aunque la vaciemos toda o busquemos borrar la caché
  demasiado vieja, por ejemplo de más de 3 días, tendremos
  ganancia de velocidad, aunque necesitaremos como mínimo
  un disco de 160, 200 o 320GB.

- ¿Por qué los navegadores web usan tanta memoria en vez de
  renderizar los documentos a disco y después leerlos tranquilamente
  como si fueran documentos PDF? La mayoría no necesita tantos
  recursos.


- Más que depender de una computadora en particular,
  tenemos que aprender a hacer computadoras estándar
  como las queremos. Así si se arruina, seguiremos con
  los mismos estándares sin preocupaciones.


- Para bajar el consumo de RAM en un sistema, necesitamos
  las fuentes sintetizadas multimedia, las cuales no gastan
  tanto ni siquiera que como un MP3, programas modulares
  hijo que solo manejen una única variante específica
  de un formato de archivo.

  También necesitamos hacer una caché de archivos procesados
  y descomprimidos solo para volver a acceder sus datos
  ya listos de disco.

  Variables de memoria y renderización de cualquier tipo de
  documentos web y locales al disco.



- Una computadora con alrededor de 1 Gigabyte, Windows 98 y DOS,
  disco IDE, video SVGA, sonido y red inalámbrica, es una computadora
  genérica que puede servir como un buen punto de referencia
  para los recursos que estarán disponibles en cualquier computadora,
  nueva o vieja, para desarrollar en función de esos recursos.

  Así, si tenemos una máquina con mucha más potencia, nuestros programas
  correrán mucho mejor en esa máquina específica.


- Hay que inventarse o usar un formato de datos en disco
  que nos permita acceder y renderizar fácilmente un archivo
  HTML en disco, no en memoria.



- Microinstrucciones algebraicas.

- Copias del código para modificarlo a la loca
  tratando de agregar cosas nuevas en donde no importa
  no agregar todos los cambios, sino que poco a poco
  reintentar hasta documentar bien lo logrado e integrarlo
  todo al kernel original.

- Normalmente todos los días debería ponerme a cambiar a la
  loca todo hasta encontrar los trucos adecuados, y una vez
  que logre, marcar separadamente los trucos de forma descriptiva,
  dónde agregarlos, y después agregarlos, de una copia del código
  al código final. Esto también debería aumentar nuestra cantidad
  de documentación y velocidad.

  Hacer eso concienzudamente para cada dispositivo, hasta implementar
  un emulador completo en el kernel de este que nos permita
  predecir, comparar, aprender cómo funcionan al 100%, y emular esos
  dispositivos para programas que lo necesitan y que estén en un
  entorno emulado estándar...


- Usar herramientas de instalación de Windows 9x y DOS
  pero terminar instalando nuestro propio sistema operativo.

- Investigar todo el tiempo hojas de especificación para encontrar
  chips avanzados y extremadamente fáciles de implementar.

- Podemos rehacer cualquier cosa, juegos, películas, series,
  canciones, historias, programas, etc... pueden no quedar exactamente
  iguales, pero siempre quedarán lo suficientemente parecidos como
  para ser igual de disfrutables, con la misma trama, secuencia,
  personajes, mapas básicos......

- Reimplementar juegos, hacerlos más flexibles y curiosos, sin
  la necesidad de vencer a los enemigos al final de un nivel
  y poder pasarlo con solo irse al extremo de la pantalla.....

- Tratar de trabajar todos los días normalmente con una copia tempora
  del código. Cada vez que se arruine o funcione algo nuevo, ajustar
  el código original y probarlo. Pero trabajar hasta que quedemos
  totalmente exprimidos.


- Buscar los documentos de donde sacaron los trucos de programación
  de otros programas en base a las palabras y frases que tiene y
  también las que se nos ocurran sin esfuerzo al simplemente ver el
  código.

- Tratar de agregar el conocimiento y tecnología a nuestra capa personal
  que no hace esfuerzo. Tendremos que buscar los puntos lógicos mínimos
  para que nos ayuden, igual que las cosas que nos sorprenden, que nos
  asustan de repente y que hacen que nos demos cuenta de algo.

- Agragar código a los programas como si se trataran de tareas
  muy variadas adicionales que queremos que el programa haga, que
  pueden ser solo de nosotros o de mucha gente.

- Tratar de balbucear alcanzando el nivel más profundo de ideas
  para pasarlas automáticamente al habla cuando aparezcan.
  No dejar de tratar hasta logarlo como cuando estábamos
  bebés, ya que aparentemente es otro nivel mucho más profundo
  y subconsciente de habla.

  Tal vez forzando limpiar cuando se nos ocurran palabras al azar,
  pero sin activar el análisis, solo conectar el subconsciente y
  darle acceso directo a nuestra habla física, hacerla sensible
  por demás al subconsciente.

- Tal vez no es que haya fantasmas cuando oímos algo sino que
  alguien está poniendo cosas viejas. Hasta donde he comprobado,
  esas cosas parecen tener cierto efecto que parece fantasmal,
  por ejemplo cuando se pone a bajo volumen, se sigue oyendo
  alguna voz.

- Parece que hay un volumen bajo que es ideal para oír y también
  para que lo que oímos entre de lleno a nuestra mente, así que
  será bueno que oigamos a ese volumen en vez de silencio para
  mantener nuestra mentalidad y contenidos deseados.

- Agregar una cantidad ilimitada de datos parcialmente ejecutables
  a nuestros programas. Registros de dispositivos, tablas de valores,
  formatos de archivos, documentos clarísimos sobre algoritmos,
  formatos, cálculo de valores, código, que podamos empezar a
  pasar en forma de datos.

  Es posible que tengamos que agregar absolutamente todo lo que se
  nos ocurra a nuestro kernel, ya que sino el hecho de que haya
  otros sistemas ya terminados y que pasaremos la mayoría del tiempo
  desarrollando nuestro sistema operativo hará que necesitemos tener
  la variedad completa de programas, recursos, dispositivos, red
  y datos en nuestro propio sistema, para poder vencer el hecho de que
  queremos que nos sirva para nuestro trabajo diario pero bajo nuestro
  propio sistema y aprendiendo todo el tiempo a hacer cosas.

- En vez de usar lenguaje humano normal, podemos usar código fuente
  como lenguaje de programación y documentación, y escribir ahí
  junto con comentarios, documentos, etc., la información que estamos
  acumulando de forma útil.

  En lugar de escribir documentos, escribiremos código.
  Y también todo lo que hagamos que nos haya servido será mejor
  que lo pongamos junto con nuestro sistema operativo, para poder
  tener todos nuestros logros en un único lugar. Así no cambiaremos
  de contextos cada vez sino que todo estará junto a nuestro kernel para
  hacer un sistema completo de todo lo que hayamos logrado entender
  sin excepción.

  Con la alta claridad del código que produzco como para sentir que
  aprendo y documento como con el código de trucos con el que he
  aprendido, no me hace falta escribir de forma no práctica, aunque
  siempre es bueno agregar 

- Agregar más funciones para imprimir números binarios, octales, decimales,
  hexadecimales en Big Endian y Little Endian, que generen una cadena
  en un búfer, ASCII, UTF-8, UTF-16...

- Quizás sea mejor agregar el código de cada dispositivo en su propia
  tarea, como si fueran drivers más formales. Con eso debería haber menos
  tiempo de espera, más paralelismo y cooperación.

* Para hacer que algo alcance inteligencia artificial quizás podría
  hacer yo primero una acción ya soportada por la computadora,
  mientras grabo cómo la hago, hasta usando las herramientas que
  espero que use la computadora. Después, debería implementar esa
  acción específica, las consideraciones y medidas tomadas a cada
  paso, como un programa.

  Podría agregar una cantidad infinita de esas tareas, pero así,
  si estas fallan, puedo maniobrar por ejemplo reiniciando el servidor
  con las mismas decisiones que yo tomo, en vez de simplemente un
  simple timer para ver si una descarga hace timeout.

  Sería como una foto o algo reproducido, pero si tengo una infinidad
  de variantes de una acción para tomar una medida, ya que la computadora
  está basada en acciones cuadradas, eso me servirá para determinar si
  algo realmente ha fallado o no.

  Esa es la importancia de hacer cosas a mano, grabarlas y después
  hacer que la computadora las repita, pero tener una librería
  virtualmente infinita de esas acciones.

- El código de mi propio sistema operativo es mucho
  más limpio si me centro en agregarle las características
  que de verdad voy a usar, no empezar por agregar cosas que
  de ninguna forma nadie, ni yo, va a usar de este...

* Tal vez la gente de OSDev prefiera basarse en que les preguntemos
  las cosas que nos hacen falta, confiados en que lo que ya sabemos
  hacer ellos lo van a ver cuando quieran, así que por eso tratan de
  bloquear cuando explicamos por iniciativa propia... ellos esperan
  que en vez de eso preguntemos lo que no sabemos.

* Hacer programas externos de prueba para un sistema, mejorarlos,
  probar que realmente funcionan sin errores. Una vez que estén listos
  y queden archivados dentro del código central de nuestro sistema,
  llegará un momento en el que terminarán de madurar, enfriarse
  y refrescarse, y es ahí donde llegará un momento en el que se nos
  ocurrirá cómo agregarlos a la base central de nuestro código
  de forma limpia y estable.

* Para agregar multitarea, lo primero que podemos hacer es agregar
  detección de memoria a nuestro sistema, y después formatear de forma
  básica con paginación. 

  Podemos usar Alt+Tab para regresar a la consola del kernel,
  o también una función de multitarea cooperativa en vez de
  predictiva (preemptive). Podemos usar programas binarios
  crudos para correr en Ring 0, programas PE EXE, MZ EXE,
  ELF, etc., para correr en Ring 3 por defecto, a menos que haya
  algo que nos indique lo contrario y a menos que el sistema
  esté configurado para correrlo todo en Ring 0.

  También una bandera para indicar que el programa está enfocado
  y evitar escribir a la pantalla si no está enfocado.

- ¿Cómo determinar si un programa ha causado una excepción de
  página que amerita denegar el acceso o concederlo? Si se
  denega, debería haber alguna forma de que el programa lo sepa,
  o simplemente terminar el proceso.











EOF
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2945
Registrado: Sab Nov 10, 2012 1:04 pm

Re: Implementar la Paginación, Espacios Virtuales Múltiples y Multitarea, y Encontrar un Primer Camino de una Aplicación Específica para Usar Genuinamente Esas Características

Notapor ~ » Sab Jul 22, 2017 12:01 am

div style="text-align:justify">
* Usar fotos como iconos y otras texturas en vez
  de dibujar para facilitar el arte en nuestro sistema
  y que de paso se vea mucho más realista.

- Antes de apurarnos a agregar más cosas a nuestro
  sistema (a excepción de las obvias), debemos ponernos
  a implementar aplicaciones externas. Es ilógico hacer
  un sistema y esperar que este mejore o que sea siquiera
  útil si no hacemos programas para este.

- Esforzarse por reemplazar código demasiado poco configurable,
  demasiado difícil de actualizar o acomodar a valores futuros,
  por otro que sí pueda, tan temprano en el desarrollo como podamos,
  para evitar dañar la compatibilidad desde un inicio, hasta usar
  métodos conocidos y probados para lograr eso, aunque nuestro sistema
  se termine pareciendo mucho más a otros existentes y aunque se
  tarde un poco más, pero todo será retrocompatible y muy configurable
  y flexible desde el principio.




2017-07-24 (Lunes)
-----------------------------------


* Hacer una "edición especial" de un programa a la que
  le agregaremos todo lo que podamos, poco a poco.

  Sobre todo, le agregaremos un índice HTML de archivos,
  una lista de texto plano de archivos, capturas de pantalla
  y logs secuenciales en HTML (para anidar imágenes y
  recursos) que nos mostrarán cómo un programa lleva la secuencia
  para hacer lo que hace.

  Un sistema operativo solo nos resultaría ideal si pudiéramos
  activar y desactivar un log que nos explique cómo hace todo,
  con capturas de pantalla, buenos dumps de registros con
  las diferencias de registros y variables nombradas en cada
  operación, etc..., ya que eso nos servirá para entender
  cómo hace las cosas el sistema entero.

  El hecho de que sea algo automático no significa que no nos
  pueda explicar en términos humanos, escrito, lo que hace de
  forma masiva para que después entendamos cómo se hace y podamos
  implementar el mismo tipo de cosas.

  Así que todos los programas que uso, TODOS, debería recompilarlos
  y crear una librería y conjunto de funciones para crear explicaciones
  humanas, como el Explicador de GIFs o de cualquier otro formato de
  archivo.

  Tengo que hacer una copia de una versión final precisa de un programa,
  agregarle esas funciones a TODO, mejorar el contenido de las explicaciones
  variable por variable, y en términos mayores, de secuencias de funciones
  MIENTRAS ESTÉ CORRIENDO, y usarlos, leer constantemente y guardar los
  logs que escriben, y así aprender.

  Lo que puedo hacer es que cada subfunción, subsistema, opción de
  menú o línea de comandos, la puedo poner en un log separado, pero
  todos indexados secuencialmente para hacer todo más manejable y
  legible.

  Es algo que requiere trabajo, pero muchísimo menos que tratar de empezar
  desde cero a entender, y algo que desde el principio me dará una cantidad
  de información tan masiva como la de los libros, pero directamente orientada
  hacia lo que hay que hacer. Hasta podríamos basar libros puramente en esta
  escritura automatizada basada en lo que los programas hacen internamente
  para quienes realmente quieren saber de inmediato y con código
  del mundo real cómo hacer las cosas.

  Creo que aunque sea un poco más lento, debería dejar una función incrustada
  aunque se llame muchísimo, aunque el programa corra más lento, pero
  esto hará que nuestro código sea más fácil de depurar y mantener fresco
  para nosotros, y para aprender de este para otros, en una función reemplazable
  por una vacía, por una que escriba a un búfer legible de texto en memoria,
  o en disco, que sería lo más normal, aunque sea en sectores crudos, para lo
  que nos servirá tener ya sea un disco tan enorme como se pueda, o tanta memoria
  como sea posible, en una máquina puramente de prueba con una partición libre
  solo para escribir el log secuencialmente.

  De ahí la importancia de aprender a compilar:

  - VLC.
  - Firefox.
  - Audacity.
  - Notepad++.
  - GCC.
  - ht://Dig.
  - Apache y PHP.
  - NASM/YASM.
  - Wolf3D.
  - FreeDOS.
  - ReactOS.
  - Sniffers.
  - Digger.
  - z26.
  - Clon de código abierto de Turbo C++.
  - SQLie3.
  - Programas y librerías de los libros de desarrollo.
  - El demo de ventanas de Alexei Frounze.
  - Los intérpretes de expresiones mátemáticas de Programmer's Heaven.
  
  - TODO LO QUE USO.

  Lo más satisfactorio para nuestra mentalidad simple es
  loggear el principio y el final de la tarea de un subsistema
  grande, y también el estado antes y después de una microtarea,
  una línea de código, instrucción o cierta porción de código.


  Hasta logguear búferes acumulativamente mostrando
  los cambios, preferiblemente en lenguaje Ensamblador
  y/o C/C++ con el progreso en el cálculo.

  Hasta podría hacer un log de los programas de trucos
  de Programmer's Heaven, Alexei Frounze, FreeDOS,
  ReactOS, Bochs, z26, ZSNES.

  WriteBookFromProgram()


estadio inicial







- Modificar los programas para ponerles nuestros propios
  íconos, estilos, etc...








* A lo que se refieren los profesores con 1 hora de clase
  es que por lo menos tienen que registrar 1 hora efectiva
  de material a dar de clases.



- Leer en cualquier momento para ver lo difícil que nos
  resulta en un momento y cuánto nos cueta entender, cuánto
  nos desconcentramos, nos dirá lo cansado que está actualmente
  nuestro motor verbal, como para hacer otra cosa... o
  reenfocarnos después de descansar y comer.


* Veo que en mi cuarto rindo menos, pero si me pongo a hacer
  videos de leer documentos de desarrollo a resolver con
  la computadora, me suelto y ya no estoy atrapado.

  Podría conseguir 1 disco por sistema operativo a instalar
  y también puedo ponerme a ver si puedo compilar los programas
  originales de un libro, modificarlos agregándoles el escritor
  de libros desde código, y puedo hacer tablas de cosas como
  paginación, sectores de disco, escaneo de bus PCI, y hacer
  que sea algo más estático, haciéndolo cada vez más dinámico.

  Además, aparte de escribir un libro, puedo tratar de ver
  si escribo código más simple en base a lo que estoy leyendo,
  por ejemplo agregando líneas con comentarios, y poco a poco
  arreglar el código para que corra sin errores.

  Tal vez esta debería ser la especialidad máxima de library.archefire.org,
  hacer libros basados en código real mientras se ejecuta
  para aprender en base a eso y mejorar los concisos
  documentos cada vez más de una forma en la que
  un programa == un libro.





* No mover los ojos ni la mente fuera de lo que estamos
  haciendo, leyendo, etc...
  Eso hará que entremos en profundidad en una tarea,
  naturalmente, que nos distraigamos y despreocupemos
  del resto, y podamos pensar sin ruido.



- Una máquina no debe solo tener el mejor hardware, sino que
  el límite de la calidad y capacidades posibles de software
  que realmente es capaz de manejar, para realmente desarrollar
  a nivel tecnológico y aprovechar los recursos disponibles.




The temporal Linux system to build LFS should be installed in
a partition intended really for swap. Reserve a partition for swap,
halve it temporarily, one half for the temporary system and the
other half for swap. When we are done building Linux From Scratch,
delete the temporary system build partition and turn it all in
swap, or leave it for future updates of the main Linux From Scratch
system.




- Un bit sticky debería hacer imposible mutilar,
  modificar, truncarss
  un archivo, pero sí leerlo y hacer otra copia
  para modificar, internamente probablemente con
  el nombre del usuario como prefijo y después
  el nombre del archivo. Tan pronto como se
  trate de modificar de cualquier forma, hacer
  una copia y redirigir todo ahí. Si ya existe,
  redirigir todos los accesos a la copia.






* Siempre aunar nuestras tareas normales
  con las tareas que son de alto nivel.
  No hacer cosas normales o de diversión
  sin mover primero cosas de desarrollo a
  la par, sin preparar lo que necesitamos.

  Aunque lo mejor será digitalizar todo, hasta
  como juego y documentos digitalizados, aunque
  tengamos que leer parte o como mínimo tomarle
  videos iniciales a los libros o cosas, para
  


- Es posible que los libros actuales de Ben Lunt
  estén pensados para no redistribuirse para hacer
  posible el no estudiarlos pero sí venderlos,
  aunque si de todas formas hago videos de estudio
  sobre ellos, leo el código en video, hago videos
  de cómo lo arreglo, y si le agrego la función
  MakeBookFromPrgram(...), pueda aprender todos los
  trucos como para hacer mi propio código rápido y
  sacar videos en base a lo que aprendí.



- PUSH/POP mental para que no se nos olvide hacer
  algo antes y después de hacer algo.



- Para estar realmente al más alto nivel de los
  sistemas operativos y la programación, tenemos que
  basarnos en usar los sistemas operativos finales y
  hacerlos entendibles con nuestros trucos y técnicas.

- Para poder tener un disco de datos 100% público,
  hacer un directorio que solo tenga contraseñas.
  En vez de guardarlas, escribir una copia de la
  contraseña cada vez que las usemos, y no guardarlas
  en los programas públicos como navegadores.

  También hacer un script de navegación que no
  sirva ni muestre datos de archivos que tengan
  la palabra "saved_passwords" o "passwords_cache"
  en la URL decodificada, y lo mismo para otros
  archivos con nombres privados en la URL.

- Si hubiera agregado todos los documentos de bajo nivel a mi
  código de kernel desde el principio, ahora lo tendría todo
  más categorizado y hubiera avanzado muchísimo más,
  pero ahora tengo que agregar todos esos documentos
  poco a poco.

- Escribir un libro automatizado es mejor que escribir
  un log o comentarios. Cuando se nos ocurra algo nuevo,
  podemos agregarlo ahí.

- Mantener un proyecto alto y otro bajo al mismo tiempo.
  Así si uno no funciona o no tiene energía, el otro nos
  la dará.


- Veo que ahora he logrado ganar $2 de forma estable con
  videos de YouTube, pero ahora necesito aumentar la
  popularidad y de hecho los resultados logrados
  en cosas raras explicadas en los videos que haga.

  Creo que lo siguiente que puedo hacer para ganar más
  es estudiar libros y otras cosas existentes, y reexplicarlas
  a mayor detalle raro y de bajo nivel en mis propias
  palabras y videos.



- Agregar la función de escritura automática de libros
  basados en programas a los snippets de trucos de
  Programmer's Heaven y similares.


- En vez de poner tantos mensajes en foros y otros
  lugares, poner toda la información en nuestro kernel,
  y avisar frecuentemente para que lo descarguen y estudien.


- Si cuesta recordar, concentrarse, etc., es porque
  estamos sufriendo demasiado ruido mental, y tendremos
  que cerrar nuestros sentidos de visión y audición por
  un rato, hasta que se nos empiecen a ocurrir otra vez
  cosas con total facilidad, hasta repetir cosas de alto
  nivel, subconscientes, mientras estamos descansando.

  Es mejor refrescarse todo el tiempo que cansarse
  al pelear inútilmente contra un ruido que solo nos
  va a desgastar.

  El mantenernos sin ruido y refrescándonos como para
  no perder energía, concentración ni hacer que se
  descalibre/desequilibre nuestra mente o sentidos individuales
  es otra cosa para la que necesitamos descansar.

  Hasta el suicidio y la ira, los vicios, etc.,
  es un desgaste común que simplemente necesita descansar
  cerrando todas nuestras características al mundo exterior
  hasta que terminemos de descansar, por eso simplemente
  tenemos que asegurarnos de descansar en un lugar en el que
  no haya peligro ni ruido estridente que nos desequilibre
  a nivel de sueño, y nada podrá preocuparnos mientras
  dormimos o descansamos profundamente.






* Mantener un proyecto de juego de código fuente activo,
  un proyecto de código fuente que refleje cada cosa de
  ocio que hagamos DE ENTRADA, para anular el ocio en sí
  y para que por defecto caigamos ahí en vez de en
  inactividad.

  Cuando se crea ocio en base a algo que queremos
  disfrutar y hasta hacer por nosotros mismos, es cuando
  se hace difícil hacer otras cosas, así que a cada aspecto
  y elemento de ocio que se haya agregado, tenemos que buscarle
  programas que hagan que caigamos ahí para seguir haciendo cosas.




* Buscar grupos grandes de programas que se compilen exactamente
  con el mismo conjunto básico y extensible de herramientas
  para poderlos manejar, compilar y desarrollar en serie.

  compiled with *
  compiled with visual studio 6
  compiled with djggp
  assembled with nasm
  compiled with turbo c++ 3.0
  .......



* Buscar los pequeños programas de utilerías que hice
  que usaban bases de datos para ponerlos en un solo lugar
  y también en YouTube y mi foro.


* Hacer videos en base a metas que sintamos que hemos logrado,
  no necesariamente planificarlas sino que simplemente por cada
  meta SIMPLE encontrada y lograda, hacer un video.





* Ni modo, si hay algo que nos cuesta encontrar, tendremos
  que duplicar esos archivos en todos los lugares que se nos
  vayan ocurriendo, hasta que ya no se nos pierdan, cubriendo
  toda nuestra mente como accesos. Eso también hará que
  las cosas raras y difíciles de encontrar se vuelvan comunes.


* ECONÓMICO. Otra cosa que hay que aprender de los anuncios que
  hemos estado viendo toda la vida, es que necesitamos anunciarnos
  constantemente, cada vez que podamos, para dar a conocer y recordar
  lo que estamos haciendo.

  Por ahora lo que más puedo anunciar repetidamente y usar para
  que vean lo que hago son los videos de YouTube, como si fueran
  anuncios extedidos y de hecho útiles de lo que sé, o lo que
  se conocería como programas (de tele, etc.).





* Veo que la técnica de repetición de onda usada en
  todos los modos que me resulten naturales, se me ocurran,
  y también a alta velocidad, hace que la velocidad de mi
  cerebro para entender cosas, como la frecuencia de
  procesamiento, aumente bastante en un momento dado
  para una ocurrencia concreta.





- Tal vez las cosas que han ido desapareciendo
  alrededor de las PCs requerían Windows 98 o a lo
  súmo, máximo pero ya casi sin funcionar, Windows XP
  y computadoras viejas, hasta servidores así...
  hasta Geocities quizás... así parecen tratar las
  cosas y funcionar para la gente que a penas logró
  hacer cosas en esa época.



- Los buscadores web deberían ser como navegadores,
  capaces de interpretar cualquier página, bajar todos
  los recursos, guardar la versión original y la renderizada
  de los archivos... sino, esa es una de las razones por
  las que se pierde tantísimas más páginas.







No salirse de nuestros propios canales de
pensamiento hacia los del ruido, si salimos
de uno, caer en otro, no en una canasta
de ruido externo que casi seguramente es
un cesto de basura mental.




Pasatiempo subliminal de que se nos ocurran
cosas al azar mientras tratamos de oír
y pasarle las palabras profundas del
subconsciente a nuestra voz, e imágenes
bien impresas también.



Ver caras aleatoriamente generadas para
tratar de ver otras caras.











Creo que entre más idiomas le agregue a los videos,
tanto más voy a poder ganar, así que debería ver cuánto
puedo ganar si por lo menos agrego traducciones para
los idiomas parecidos al Español a los videos más
populares que he subido (Portugués, Catalán,
Francés, Italiano, además de Inglés y Español, y también
buscar alguna redundancia traduciendo y después usando
la computadora para que pronuncie en esos idiomas).

Como mínimo, debería poder ganar más fama, pero voy a ver
si traduciendo mis videos más famosos y los nuevos,
eso pasa, y a medida que aprenda esos idiomas, vuelva a
revisar las traducciones y hacerlas a mano.





* Como mínimo hacer un video de cada mensaje de los
  ciclos de trabajo que complete para después poder
  volver a oírlos y así profundizar un poco más en mis
  metas.


  Aprovechar traducir para darle más forma y alimentar
  de hecho la base de datos de idioma humano.





Hacer cosas multiidioma válidas aunque sea en video
y los temas clave del sitio y foro hará que se anule
en buena medida el spam, aunque sea una traducción
tan automática como el spam, así que eso también atraerá
mucha atención.


Pero traducir entre los idiomas que se parezcan más
entre sí para que la traducción sea mejor, por ejemplo
todos los idiomas basados en latín/romano que se parezcan
del Español al Francés.

Todos los idiomas que se parezcan desde el Inglés al Alemán.

Del Griego al Ruso y nórdicos.

Del Tailandés al Chino (Filipino, Japonés, Coreano).

Del Hindú a otros idiomas similares a scripts, egipcio, y arábigos/hebreo.

Lenguas africanas.











Hay que animarnos. Si implementamos los ejemplos
de código de un libro no necesitamos leerlo ni
reescribirlo todo, solo el ejemplo, a veces solo
una parte de este, así que de hecho vamos atener
más tiempo y vamos a terminar más rápido
de lo que creemos.





Tratar de empezar a separar palabras aunque sea de
diferente gente solo para usar lenguaje natural, y
después hacer copias ordinales, una tras otra,
para oirlas después de alguna forma´.




No dejar que se disipe nuestra energía,
vitalidad u otras cosas. Cerrarlas y
regresarlas igual que otras heridas.







Buscar archivos de imagen, sonido, etc.,
que induzcan alucinaciones y percepción
pseudoparanormal... Una vez cerrada una
percepción negativa, mejorar lo que realmente
tenemos.







Si usamos la técnica de repetición de onda para
oír todo el tiempo una misma cosa, como un mismo
curso de un idioma, vamos a terminar aprendiéndolo
muchísimo más rápido.

También podemos hacer videos de audio de nuestras
mejores ideas y oírlos repetidamente para tratar
de detectar por dónde van las ideas más profundas.





Tal vez no logro capturar todas las ideas porque
debería estar en una única cosa, un único tema,
y basado solo en implementar. Fuera de eso, es
posible que pase un buen tiempo antes de que logre
hacer que las ideas profundas logren imprimirse
en mi conciencia normal mientras estoy descansando.



Cerrar las acciones igual que cuando cerramos los
ojos. NO soltar lo que hagamos, hacerlo con la actitud
de que estamos agregando algo, y terminarlo.


Mientras haga algo en un ciclo de trabajo, no debería
hacer absolutamente nada más para de hecho lograr
terminarlo. Entre más crítico algo, más debería
concentrarme solo en eso. Encerrar algo en un ciclo
de trabajo hace que no pierda tiempo en nada de lo que
haga, así que esa no debería ser una preocupación.






Como mínimo debería aprender a compilar y entender
lo interno de las herramientas que use, y sacar ideas
orientadas a mis metas de ciclo de trabajo del resto
de cosas que vea, pero no salirme realmente de los
temas que necesito resolver en ese ciclo.





Podemos estudiar cosas y aunque no entendamos del todo
las fórmulas y algoritmos, podemos usarlos manual y
mentalmente de forma humana para mejorar nuestra vida.








* Tal vez usar Visual Basic, que me gustó tanto para
  empezar a aprender a hacer programas de Windows,
  desde Visual Basic 4 o 6, me pueda ayudar para reimplementar
  de la forma más fácil posible la WinAPI, aunque tenga
  que hacer un editor de Visual Basic a Ensamblador
  en HTML5.







- Buscar y bajar TODO lo que podamos ANTES dwe terminar
  comprándolo para balancear todo lo que potencialmente
  no podremos comprar con nuestra nueva técnica de comprar
  primero y pagar después la tarjeta con un poco más en
  efectivo para eliminar los intereses y las deudas y
  que funcione más como una tarjeta de débito, solo para
  pagar cosas que necesitan PayPal, y tambíen para lo que
  realmente tampoco podremos.

  Con esta técnica de verdad se siente como si estuviera
  levantando una enorme piedra económica, aunque tengo que
  esperar un poco más, ir a comprar al banco, comprar primero
  y después pagar el mismo día. Pero levantar esa piedra
  se siente más cómodo y todo más en fila que si simplemente
  comprara en cualquier momento al azar y después solo pagara
  lo que pudiera al final de mes, que es cuando se agrandan
  los intereses y la deuda.





- Aplicar todo lo que sé de sistemas operativos también a
  Java, y ahí también crear un libro a partir del código
  de los mejores programas de código abierto, para conectar
  ese nivel con el de los sistemas operativos y otros
  mejores que Java crudo.






* Ejecutar de forma no verbal cualquier idea.
  No retener realmente su contenido verbal
  sino que el resultado entendible de cuando
  tratamos de ejecutarlo.

  Si nos aparece algo de repente, también
  ejecutarlo, y agregarle los proyectos que
  tenemos para ver las cosas desde esa perspectiva
  y tratar de hacer encajar, entender siquiera
  la lógica de nuestros proyectos, ideas,
  mente, kernel, y hacerlo concordar y volverse
  usable y presente en los niveles de acción y
  pensamiento normales.




* En vez de guardar imágenes estáticas, sería mejor
  crear una o varias formas conjuntas de ejecutar un
  programa para generar una imagen, por ejemplo un juego
  de Nintendo y darle un estado guardado previamente
  jugado y en pausa o bucle... sería el mismo procedimiento
  de tomar una captura de pantalla pero en menos espacio que
  una imagen estática, en muchos casos, también preservaría
  más las cosas usables, así que es mejor que la compresión.




- Para clústeres con mucho espacio libre, leer solo
  los datos válidos en el búfer final y el resto en un
  mismo registro para descartar el resto de la lectura.





- Llevar TODO lo que hemos hecho específicamente EN BLOQUE,
  otro bloque de las cosas que nos han servido pero que han
  hecho otros, y otro bloque global para expandir infinitamente
  todo el entorno para retroalimentación y para un estado
  general normal.

  Sea lo que sea que hagamos, no separemos todo de una vez,
  sino que llevémoslo todo con nosotros. El hecho es que
  todos nuestros proyectos son la base con la que podemos
  construir mucho, es lo que realmente va a permitirnos
  movilizarnos, y por eso va a servir usarlo hasta a nivel
  de nuestra propia mente para ganar experiencia que
  después podamos usar sobre el proyecto implementado
  fuera de nosotros mismos.



- Implementar la WinAPI en JavaScript.
  Usar HTML5/JavaScript de bajo nivel para
  implementarla usando los tipos estándar que
  de verdad se usan al llamar las funciones,
  en pila, etc., las estructuras, y después usar
  las capacidades de HTML/JavaScript/Java para
  avanzar. Desde ahí podemos reemplazar poco a poco
  las funciones, teniendo ya un esqueleto accesible
  de forma extremadamente fácil, hasta tener la lógica
  nativa y lógicamente portable de una WinAPI completa.

  De un esqueleto funcional usando la capacidad de
  JavaScript y HTML5, a funciones que implementaremos
  poco a poco desde cero... lo primero que nos quedará
  será una WinAPI para el web y poco a poco conectada con
  el formato estándar de Win16 y Win32, cuyo modelo
  también deberíamos implementar poco a poco en JavaScript,
  lo mismo que para los sistemas de archivos, la multitarea
  y paginación, para usarlas de verdad, hasta acceder el
  disco para hacer swap fuera del disco cuando la memoria
  asignada a nuestro programa se acabe de acuerdo al
  sistema de administración de memoria que modelemos
  cuidadosamente como microinstrucciones.

  Pero JavaScript/HTML5 definitivamente es el lenguaje
  que nos va a permitir modelar inicialmente los proyectos
  más difíciles que tengamos en mente, al usarlo también
  con el estilo de Ensamblador y de microinstrucciones
  ultraminimizadas y portables.

  Quizás lo mejor que hay en Windows XP y posterior
  sean los emuladores, el Ensamblador y HTML5, con los que
  podemos tener acceso a las características más avanzadas
  de una computadora, mientras que en Windows 9x y DOS,
  lo más avanzado era hacer todo desde cero, a nivel de
  hardware, con Ensamblador, y no dejar que las raíces del
  conocimiento se mutilaran parcialmente como para que la
  falla de las bases nos entorpeciera el resto.

  Seguimos necesitando entender el 100% de los formatos de
  archivo, estructura de memoria, disco, etc., para entender
  cómo avanzar un sistema operativo, así que esos trucos son
  lo primerísimo a investigar y pulir antes que creer que
  podremos lograrlo simplemente tratando. Igual que como me
  tardé unos 12 años en hacer un sistema simple con consola
  de kernel, teclado PS/2, modo texto, y capacidad de
  interpretar líneas de comando para correr comandos internos,
  programs externos, y pasarles la línea de comandos,
  aquí tengo que darme cuenta que lo que necesito es completar
  las bases mínimas, TODAS, ANTES de siquiera pensar en que
  voy a poder sostener más logros sin esa base sólida y real
  de conocimientos.

  Solo por decir que el instalador de Windows 3.x sigue siendo
  el instalador base usado en Windows XP, actualizado, pero
  el mismo... se siente que es la misma base de código...


  Pero cuando modelemos en JavaScript, INMEDIATAMENTE, cada
  función de microinstrucción que nos quede bien hecha,
  reimplementarla en Ensamblador x86 Portable y usarla en
  aplicaciones.

  Las primeras aplicaciones son pruebas lógicas y una comprensión
  más profunda en nuestra mente.

  Y no olvidarse de usar todo lo que estudiemos a mano para hacer
  usables las cosas raras en el nivel normal, en la vida normal,
  en cualquier cosa que hagamos... otra cosa que me enseñó mi
  amiga gata.



* Windows 7 se siente como una base de código ahogado, cosas que
  han hecho con extremo sacrificio y que tal vez no entienden del
  todo........





* Ver cosas que normalmente no vemos cuando estamos sucios
  cuando vayamos a bañarnos o hacer otras cosas que solo nos
  gusta hacer cuando estamos limpios. Eso nos dará gran energía
  y de hecho hará que las veamos cuando podemos considerarnos
  limpios mientras nos estamos bañando...... todo se acelera
  y se ilumina.......





La piel es un tejido, una fibra, que puede tratarse
naturalmente para mejorarla, alimentarla, hacerla más
resistente, fácil de curar, viva y tierna
hasta en la superficie, rejuvenecida todo el tiempo....



Implementar la función WriteBookFromProgram
en todos los lenguajes de programación y versiones
de compiladores y herramientas que usamos.










* No abrir los ojos hasta que un concepto sea
  totalmente claro y no difuso, para implementarlo.

  No regresar a opinar a OSDev.org hasta que termine
  el ciclo de trabajo. Mientras tanto solo revisar nuevos
  sistemas operativos y navegarlo igual que cuando no
  nos habíamos registrado, que es cuando más rendíamos.




  El problema es que realmente estorba discutir en sitios
  de desarrollo de alto nivel cuando lo que se dice no está
  basado en nada práctico.



  La forma más práctica en la que
  puedo implementar esa función para cada
  entorno es haciéndolo a medida lo necesite,
  y basarme primero en los progamas finales
  que uso para aprender, después en demos,
  en programas de nivel no profesional pero
  complejos como los de OSDev.org, VisOpSys,
  de Ben Lunt, MenuetOS, ReactOS, en libros
  y en no apagar mi creatividad en ningún caso,
  usar siempre el cerebro.

  Además, puedo rellenar todas las tareas con juegos,
  buscar aplicaciones de jego del mismo tipo que
  las formales, y cada vez que me distraiga en cualquier
  cosa, agregarle llamadas a esa función a cualquiera de
  los anteriores, de juegos y sistemas operativos
  para arriba.


  Es nuestro cerebro el que necesita mantener ejecutando
  y teniendo presentes los programas. Nuestro cerebro
  ejecuta en base a explicaciones claras, que podamos
  escalar. La computadora normalmente Así que normalmente
  lo que tenemos que hacer es unir nuestro estudio,
  ocurrencias, análisis y documentación basada en ese
  estudio, con la implementación de WriteBookFromProgram(...).
  Con eso cualquier esfuerzo de entender algo lo vamos a
  aplicar inmediatamente a código que genere automáticamente
  un documento secuencial y estructurado, en vez de tener que
  deducir a mano una cantidad descomunal de código. Con esto
  lo resolvemos y hacemos que la computadora vaya un nivel
  más allá para ser extensión de nuestro cerebro.
  La computadora puede ejecutar normalmente sin hacer
  esfuerzo, somos nostros los que tenemos que hacer la
  computación más fácil al pasarnos todo el tiempo,
  al pasar normalmente, haciendo nada más que llenando
  el código de llamadas a esa función para escribir el
  libro automáticamente en base a este mientras se
  ejecuta. Ambas son cosas lógicas que se pueden generar
  en paralelo, con las versiones originales sin esa
  función, y nuestra versión para generar un libro.

  Después de un tiempo de aprender a compilar muchos
  programas, de haber estado puliendo la forma en la que
  esa función genera los mensajes de depuración,
  y de estudiar los libros generados,
  podremos reimplementar muchas cosas cada vez
  más fácil, desde programas completos hasta
  librerías oficiales de los cuerpos de
  estandarización. Hasta Linux podremos
  entender fáci de esta forma.

  Así que normalmente solo necesitamos
  escribir código para escribir libros
  automáticamente dentro de los infinitos
  programas que existen; el hacerlo así
  también nos ayudará a llegar a un punto
  de productividad como para poder ganarnos
  la vida masivamente.

  Si otros saben esta técnica, esto les
  ayudará a todos en conjunto, ya no es
  competencia... podemos usar la computación
  así para acelerar la gratuidad de todo
  lo disponible...... no hay límite conocido.....

  Normalmente cuando no tenga energía ni una forma
  de trabajar principalmente en una computadora con
  CPU nativo, tengo que usar los mejores emuladores
  disponibles, empezando por DOSBox, Bochs,
  VirtualBox. Después tendremos que comprobar que los
  programas también funcionan bien en hardware real,
  ya que eso es lo que realmente interesa, y seguir
  consiguiendo el mejor hardware clásico para estudiarlo
  y reimplementarlo en algún momento.

9241993150872855762108




* Don't switch tasks, thoughts, return immediately
from functions if you cannot save the stack.
Create a case where a global variable indicating
to wait for task or to flush it before continuing
so that the program can decide... We will have to
perfect that technique.




* El Atari 2600 te puede enseñar sobre memorias y hardware,
  ya que estaba totalmente basado en usar esos componentes
  para correr los juegos.


* Hacer un compilador de recursos en HTML5.





visual basic write files





* Tenés que descrubrir lo que tiene Windows de especial por
  dentro. Cuando eso pasa, todos tienden a aburrirse y abrir
  el código fuente o la tecnología poco a poco en ese
  proyecto particular.

  Tal vez lo mejor sería hacer clones idénticos en todos los
  aspectos, pero para eso necesitaríamos técnicas para
  analizar el comportamiento a cada paso, hasta de juegos,
  de programas grandes, empezando con nuestros propios formatos
  de archivo y APIs pero tan parecidas a las originales, y
  poco a poco hacerlas internamente iguales.

  Sería un trabajo de observación técnica, que escriba un
  libro paso a paso de forma automatizada de acuerdo a lo que
  visualicemos.




* Hay flashes de salud que tenemos que alcanzar y aprovechar
  curándonos todo el tiempo para que cuando deje de estar cansado
  el cuerpo o una parte, avancemos en curarnos de cualquier cosa.




* En este momento el secretismo que hay es tan grande que
  parece que se necesita registrar todo lo que se hace,
  en video, poco a poco, para ponerlo tema por tema,
  tarea por tarea, para poder acumular y reanudar las
  tareas, para que nosotros y otros las puedan estudiar,
  y para romper la influencia psicológica, intelectual
  y práctica .

  Eso hasta me destraba del tedio. Puedo hacer sea lo que
  sea, rápidamente acumular videos interesantes de lo que
  he hecho, y poco a poco subirlos en masa para mover la
  situación y el ambiente entero hacia resolver de muchas
  formas prácticas la falta de estructuración que antes
  estaba disponible con la gente que creó los dispositivos
  electrónicos y programas, que no eran más simples, eran
  muchísimo más eficientes que los de ahora.






  Las cosas "obsoletas" realmente son obsoletas para el
  secretismo, pero perfectamente útiles y necesarias para
  el desarrollo tecnológico del público en general.






La mejor forma de depurar nuestro kernel inicial como para
hacer un libro será reservar una porción fija de memoria,
escribir ahí, establecer un límite para no pasaros, hacer
un visor de memoria como HIEW para ver la memoria haciendo
scroll en el búfer de texto, y usando eso como un buen libro
generado. Una vez que tengamos suficientes funciones podremos
escribir lo que hagamos al disco cuando el búfer se llene,
con doble búfer para poder seguir logueando cuando el sisema
sea lo suficientemente avanzad. Así siempre podremos tener
un libro actualizado que refleje la forma de ejecutarse
más reciente para nuestro kernel actual, con lo que el código
y la documentación siempre estarán perfectamente actualizados
y depurados a la par para la versión que está corriendo
actualmente de un programa... hasta podemos hacer que ese
log se desactive o active en tiempo de ejecución.......

Creo que voy a necesitar eso para facilitar lo más posible
seguir desarrollando en mi sistema operativo cosas más
difíciles y desengañarme en todo momento de los valores
realmente presentes y la estructura de lo procesado,
para ver si es como yo quiero, y sino, cambiarla hasta
que sea exactamente como debería.

Y lo mismo obviamente para el resto de programas.





* Llenar un programa de funciones para generar un
  SourceDoc automático se tarda tanto como cuando lo
  estudiamos normalmente, y realmente entendemos más,
  vemos lo que está pasando en realidad, y el esfuerzo
  es mucho más provechoso y educativo, ahora con la
  computadora como nuestra profesora basada en información
  para un libro sin error alguno.

  Ahora todos los programas que sabemos cómo compilar y
  para los que sabemos generar cadenas, convertir números
  a cadenas, entre otras cosas (es decir, a nivel pleno
  de sistemas operativos) son clases perfectas, estudiamos,
  las mejoramos, les agregamos cada vez más, hasta que todo
  quede clarísimo.

  Y si no sabemos cómo generar los datos bajo un entorno,
  simplemente aprendemos. Es lo menos difíci y la ganancia
  es extremadamente enorme.

  Debería agregarle este código a mi Explicador de GIFs
  para que realmente quede bien explicado el proceso de
  descompresión y renderizado de un GIF, aunque con esta
  técnica de automatización todo se volverá un explicador.

  Lo más difícil que tengo es cómo guardar los datos si
  estoy en modo protegido o con disco inaccesible. Lo más
  que podría hacer sería activar el Modo Irreal, o un búfer
  de por lo menos 4 Megabytes (tantear de acuerdo al máximo
  o por lo menos de 2 a 4 veces más, para los datos generados
  en la máxima corrida normal).

  Que el programa nos avise cuando se llene el búfer.
  Una vez estemos en un entorno accesible, escribir dicho
  búfer al disco, o si estamos emulando memoria plana solo
  extraer la porción que nos interesa.

  Nos servirá limitar el tiempo de corrida si el búfer se
  acaba demasiado rápido siempre, y también nos servirá
  seguir donde estábamos.


  Así que en general para tener acceso a las funciones que
  tenemos lo que más nos servirá será valernos de código
  escrito en entornos que tengan acceso fácil al disco,
  o traducir código de bajo nivel sin acceso a esos lenguajes,
  haciendo todo en forma de microinstrucciones y después
  obteniendo los datos del libro a escribir a un nivel que
  nos permita estudiar y reimplementar.

  Pero debo hacer absolutamente todo lo posible para que
  para cada pequeño programa de bajo nivel, pueda reservar
  un búfer en el espacio mínimo de memoria de 4 Gigabytes,
  pueda loguear el texto de bajo nivel ahí y otros datos
  como mapas de bits, y después pueda tener el cuidado de
  no destruirlo para hacer un dump de este desde el
  programa mismo.

  Pero ya hay muchísimas tareas, en Windows y Linux, en
  donde puedo valerme de código de mayor nivel, con acceso
  al disco, para aprender muchísimo.

  Obviamente, la paginación y el acceso al disco me van
  a servir para hacer un sistema extremadamente educativo,
  y la multitarea para poder correr software multiplexado con
  muchos hilos y procesos simultáneos.


  Ahora solo tengo que seguirle agregando código de
  escritura automática de libros técnicos a cada programa
  hasta que me sienta satisfecho de lo que he logrado
  aprender hasta ese momento, aunque poniéndolo en
  un repositorio de documentación este código capaz de
  escribir un libro sobre sí mismo (que tengo que hacer
  para archivar y continuar mi desarrollo)
  voy a poder agregarle frecuentemente más de ese código
  hasta que sea mejor que los tutoriales actualmente
  en existencia.

  Hasta para dar clases muchísimo mejores me podría
  servir esto, tal vez muchos profesores mundialmente
  hacen esto para ser muchísimo mejores, y por eso todo
  lo que hacen se nota muchísimo más complejo.

  Hasta las cosas de inteligencia artificial podría
  entenderlas muchísimo mejor con esto, hasta ht://Dig,
  SQLite3, GCC... lo que sea............


  Ya que mi sistema está en Ensamblador, tengo que
  asegurarme de implementar esas funciones de autodocumentación
  en Ensamblador Portable, y también ver cómo inteceptar puntos
  de un ejecutable para explicar lo que está pasando.

  Debería hacer eso urgentemente con ReactOS y todos los pequeños
  sistemas operativos, aunque para estos tengo que buscar una
  forma de escribir un búfer continuo de memoria que pueda
  guardar después, o que pueda leer mientras corro el sistema,
  como si se tratara de un libro estrictamente digital,
  aunque si pasan cosas interesantes o errores y no puedo
  escribirlos al disco tendré que grabarlos con cámara o
  en un emulador con captura de pantalla.


  Con esto toda la riqueza del software está a la mano,
  entusiasma tanto que ni siquiera debería seguir escribiendo
  esto sino que seguir trabajando... hasta ahora solo he
  agregado código para generar ese libro para el tutorial 1
  de Alexei Frounze, pero de aquí en adelante tengo que hacer
  eso masivamente para poder responder preguntas al presentar
  ese material educativo autogenerado sin errores basado
  en código del mundo real...

  Si logro implementar esto en Ensamblador y otros lenguajes,
  ganaré verdadera experticia al cambiar, entender y manejar los
  datos de los programas......

los diferentes programas

  Con esto tengo más recursos para poder reimplementar programas
  con las versiones más nuevas, a sistemas viejos, reimplementando
  todo lo que entienda.


  Es como parte de la técnica de conocimiento infinito instantáneo.




* Lo primero que debería hacer sería aprender a recompilar
  CWSDPMI, ZSNES, Z26, los diferentes programas de FreeDOS,
  Wolf3D así como está actualmente, y agregarles esas funciones
  para que quede escrito cómo hacen todo, multitarea, paginación,
  administración de memoria, y con esos ejemplos tener datos para
  basar lo que necesito reimplementar en esos aspectos...
  así que ya que CWSDPMI con ZSNES sería uno de los mejores
  recursos para aprender eso actualmente, eso es lo que tengo que
  aprender a recompilar y agregarle rápidamente todo ese código.

  Navegadores simples, XMMS, la base de Slackware 10/12, que son las
  versiones más importantes para aprender... lo mejor es que prácticamente
  todo lo más difícil se podría aprender emulado como a nivel de software
  que alcance el nivel de hardware, así que puedo emular esas versiones
  importantes de Linux.




  El sistema operativo más capaz que tiene todo lo que necesito
  reimplementar desde cero y que solo usa la parte más baja de la
  memoria es FreeDOS, sé cómo compilarlo, así que debería pasarme
  normalmente el tiempo agregando código para escribir un libro
  por cada vez que lo ejecute, con un nombre aleatorio o de la fecha
  actual, como para poder entender todo lo que hace y expandirlo
  a Ensamblador x86 Portable para los modos de 32 y 64 bits,
  aprendiendo rápido los trucos de sistemas de archivo, periféricos.
  Podría generar un búfer de 1 GB de texto y simplemente hacer dump
  del Gigabyte entero al disco duro.

  Después, otras cosas basadas en DOS como el sistema operativo de
  Ben Lunt también debería arreglarlas del mismo modo, a Cute Mouse,
  a TODO lo de DOS.


  Después compilar un ReactOS arreglado para empezar por aprender
  los detalles más básicos de la plataforma Windows y poder reimplementarlos
  rápido. Todo eso podría emularlo aunque tenga que instalar y emular
  solo un sistema a la vez, podría en el más crítico de los casos emular
  un disco IDE solo para logs, sin formato, escrito secuencialmente por
  todos los componentes del sistema con un puntero global de sector,
  que después podría hacer dump en un archivo normal.

  Esquivar todo el sistema como para poder loguear TODO va a hacer
  que entienda muchísimo más esos sistemas, y que logre desencriptar
  una cantidad de información tan grande y de una calidad tan rara
  que se resuelva en enorme medida el problema de falta de educación
  en tecnología de computación, de software, ahora a cargo de un
  esfuerzo automatizado y masivo pero para lo que tuvimos que estudiar
  muchísimo para generar buenos libros y para poder loguear todo lo
  que pasa en el sistema, en cada subsistema, globalmente, en cada
  aplicación........



  Como mínimo debería reservar como mínimo de 512 MB a 1 o 2 GB para
  el log de texto del sistema, accesible a todos para leer.
  Así podría copiar fácil lo que hace el sistema, depurarlo
  y sacar el máximo provecho de mi memoria... así que probablemente
  debería conseguir una computadora con por lo menos 2 or 4 GB
  para lograr aprender de forma sostenida, de todo el buen software
  que existe hasta este año 2017 hasta atrás.....


  Con esto nos tenemos que hacer expertos en crear documentación
  valiéndonos de la computadora como una gran calculadora para
  crear libros sin errores, y si hay errores de programa,
  identificarlos de inmediato.

  Aunque tal vez necesitaremos hacer nuestra propia copia
  de las versiones finales de todos los programas en cada
  número de versión de interés para convertirlos en libros
  más que programas no transparentes.







- Definir o hacer calculables de alguna forma los tamaños de
  los conceptos en programación, por ejemplo, entre print, printf,
  unsigned, integer, para poder englobar de forma lógica y armar
  algo que tenga sentido.





lfn from turbo C

- Tratar de usar doslfn y crear un archivo
  de nombre largo en Turbo C, a ver si se puede.+






- ¿A quién le importa cómo estén hechos los proyectos
  oficiales? De alguna forma tienen que estar hechos.

  Lo que realmente queremos es saber cómo fuincionan,
  que los programas nos enseñen cómo hacen sus cosas,
  y desde ahí hacer nuestras propias implementaciones.

  Para Linux, podría usar una PC para correr una versión
  modificada, o un emulador con 2 discos IDE.

  El primer disco funcionará normalmente, el segundo disco
  se manejará única y exclusivamente fuera del contexto
  del kernel, solo con funciones de escritura para ATA LBA
  de 28 bits o 48 bits, sin ser usado por nada más, con
  nuestro propio código, para las partes del sistema de
  Ring 0 o que en general no podamos alcanzar.

  Un sistema de archivos ya conocido o nuevo, o hasta un
  disco crudo o con FAT32 LBA siendo manejado a bajo nivel
  fuera del contexto del kernel, un disco crudo o con un
  sistema de archivos inventado por nosotros o cualquiera,
  puede servirnos para depurar el sistema operativo normalmente
  inaccesible en tiempo de ejecución hacia un disco exclusivo
  para usarse fuera del contexto del kernel, aunque este lo
  monte.

  Eso aplica a todos los sistemas complejos, Linux, ReactOS,
  BSD, FreeDOS...

  Más allá de eso podemos usar un búfer como mínimo en el último
  Megabyte usable en el sistema.

  Fuera de eso, para programas normales, será fácil escribir
  en disco el libro de desarrollo por parte del programa, pero
  como vemos hacer debug de un sistema entero a nivel de
  kernel privilegiado no es mucho más caro, solo necesita
  1 disco IDE adicional solo para eso.








* Ejecutar absolutamente para que nada nos deje
  con lagunas de confusión.

  Lo primero que el olvido artificial trata de
  hacernos olvidar es el vínculo hacia las acciones
  que necesitamos tomar inmediatamente.

  Todos los contextos mentales tienen un entorno,
  pila, etc., que recordar y aprender. No debemos
  dejar que el mero ruido nos cambie el contexto
  mental. Si no podemos guardar al 100% en nuestra
  mente, tranquilamente, por sí misma, al bloquearnos,
  el contexto actual de nuestros pensamientos, sea el
  que sea, monotarea, multitarea o global/universal,
  si no podemos registrarlo en nuestra mente hasta que
  se nos olvide que lo estábamos registrando pero sin que
  nada se nos olvide antes de cambiar tarea, entonces
  simplemente no cambiar nuestro contexto mental.





* Nunca dejar de correr programas, tratar todo
  como una única corrida, sea booteo, encendido,
  un programa... así siempre estaremos pendientes
  de cuál es el estado a preservar y usar en todo
  momento.



http://forum.osdev.org/viewtopic.php?f=1&p=277975#p277975









* Mejor usar todas mis técnicas globalmente en
  cómo hago las cosas, en vez de realmente preguntar,
  anunciar lo que está pasando cuando ejecuto programas.

  No encerrarse en un tema sino que implementar una forma
  de hacer las cosas globalmente en cómo hago en sí mis
  cosas.







* Sabemos que normalmente siempre cambiaremos de
  contexto por cada pensamiento, que es lo más fácil
  que puede pasar, así que tenemos que guardar
  el contexto, la pila mental, de cada pensamiento
  que nos interese realmente, y quedarnos en esos
  pensamientos hasta que naturalmente se calmen
  y pasemos a otros, pero habremos profundizado
  en sus contextos y ahora lo que queremos pensar
  será lo más frecuente, no el ruido.





* Para programas sin código, podríamos
  buscar alguna forma de escribir libros
  automatizados por bloques de instrucciones,
  rutinas, etc... aunque no lo descifremos todo,
  aunque sea parcial, lo que descifremos en
  tiempo de ejecución nos dará cada vez más
  idea de que se trata, y ya que tenemos
  el binario, siempre podremos seguir
  mejorando el borroso documento que generemos.

  Solo tenemos que buscar una forma o un depurador
  que nos permita seleccionar porciones de binario,
  ejecutarlas, después detenerse e inpeccionar TODOS
  los cambios hechos por el programa, TODAS las acciones,
  y esas las describiremos desde el depurador
  para generar el documento desde el depurador.....




* Todo lo que tengo que hacer en esta
  etapa es simplemente agregar código para
  crear libros automáticamente a medida que
  un programa se ejecuta.


* Puedo usar las versiones de C y C++ de los programas
  disponibles como un script para aprender las cosas
  lo más rápido posible y después pasarlas al lenguaje
  que yo quiera al tenerlas documentadas.








* Es posible que si solo pasamos manteniendo objetos
  visualmente y sensorialmente en general de forma persistente
  en nuestra mente, eso termine ayudándonos en nuestros
  sueños lúcidos y aprendizaje, algo parecido a memoria
  fotográfica.

  También mantener todo el tiempo conversación casi verbal
  interna, que tenga cierto sonido pero que no colisione con
  la verbalidad normal del ruido, y que cuando termine
  de formarse no se puedan bloquear junto con nuestras
  ideas.

  Podríamos usar esto para aprender y cargar en nuestra
  mente todas las cosas, cotidianas y de estudio, que más
  nos interesen.












2017-08-01 (Lunes)
------------------------

* Buscar comida y acciones que no destruyan nuestra
  energía, sino que nos permitan hacer más.



* No tenemos que apartarnos de las cosas de desarrollo.
  Tenemos que persistir, mantenernos presentes ahí.
  Igual que en todo lo demás, hay momentos aburridos y
  momentos divertidos, solo tenemos que esperar que aparezcan
  los momentos divertidos, seguir reintentando hasta que se
  haga mental, vital y existencialmente fácil y divertido.
  Son los momentos los que queremos esperar, no el lugar de
  trabajo, aunque los momentos divertidos nos van a llevar a
  lugares de trabajo con hábitos sanos, cosas cómodas para no
  dañarnos el cuerpo mientras trabajamos, todo lo que necesitemos
  para sentirnos frescos y súper bien como en los años
  cuando empezamos a aprender cosas de desarrollo.

  Otra cosa es que deberíamos mantenernos en programas finales
  que nos cuesta entender. Como sabemos, son los programas que
  usamos para hacer nuestras cosas normalmente en la computadora,
  son los que realmente tienen las cosas más completas, más que
  la enorme mayoría de libros, tutoriales, demos sobre un tema
  específico, aunque si estos están bien hechos también pueden conformar
  una buena librería, como lo que estoy haciendo, y las cosas de
  Programmer's Heaven y similares.

  Pero en general, sobre todo para los temas menos comunes,
  más especializados e internos, es mejor rebuscarse de infinitas
  formas para aprender de programas de código abierto y de código
  cerrado (estos últimos usando depuradores en secciones de código
  binario para los que generaremos mensajes de libro automatizado).

  Comparado a aprender de esta forma con los programas en cuestión
  mientras corren, la enorme mayoría de libros prácticamente
  ofrecen más de lo que realmente contienen, a menos que hayamos
  comprobado que realmente fueron bases para nuestro aprendizaje
  inicial.

  Así que tenemos que usar esos programas de todo tipo de aplicaciones.
  Es como inspeccionar la mente de alguien que sabe cómo hacer
  esas cosas sin errores, así que esa es actualmente la fuente principal,
  además de las referencias generales y completas de APIs y trucos, una vez que
  tenemos cierto conocimiento que nos permita tener ese tipo de ideas.




**************************************************
**************************************************
**************************************************

* Después también vamos a necesitar hacer un programa,
  código fuente, a partir de el libro automatizado que
  hemos hecho. Con eso podremos sostener más lógica a
  la vez, generar código fuente limpio que de hecho
  hayamos pasado por estudiar humanamente, aunque sea
  muy masivo, y así también vamos a poder leer repeticiones
  masivas con WriteCodeFromBook(), que después podríamos
  perfeccionar para escribir código a partir de libros normales,
  hasta comparando palabras, frases y porciones de código
  normales, para escribir uno u otro código, o para traducirlo
  a código, y después arreglarlo para que de verdad funcione.

  Parece que hay muchos bichos que estudian en base a comparar
  cadenas de texto, palabras, como indexOf, strcmp, stricmp...

  Con esto vamos a poder llevar un poco más arriba la lógica
  de nuestro estudio de forma limpia y automatizada...





* Hacer las cosas con la gente, situaciones y temas que más nos
  importan solo cuando estemos en la mejor situación posible,
  más limpios, acabados de bañar y lavados de los dientes,
  cuando estemos más descansados, cuando realmente estemos al
  máximo de estar listos para hacer, usar o comprar algo,
  cuando estemos totalmente descansados y con entusiasmo.

  Antes de eso, solo mantenernos preservándonos, descansando y
  esperando el momento óptimo para ir a un lugar, hacia una persona
  específica, hacia una situación o tema específicos a asistir
  o estudiar.

  Mientras tanto, ensayar si es mejor dejar el hasta pensar plenamente
  en algo o alguien, o conceptos a estudiar, o cosas como la computación
  o la programación, solo hasta que estemos bañados, limpios,
  y al máximo, ensayar para cada persona, situación, objeto, tema, acción,
  si es mejor prepararnos a estar en nuestro mejor estado, si es mejor
  prepararnos individualmente para uno de esos, o si es mejor colectivamente.
  Para algunos será mejor individualmente, para algotros será mejor
  colectivamente de forma global o a diferentes niveles. Eso hará que
  estemos todavía más al máximo. Para algunas cosas un modo será
  demasiado pesado, para otras otro modo será ideal de manejar,
  trabajar y acompañar de forma agradable y sentirnos jóvenes,
  hasta prepararnos para nosotros mismos, nuestra vida, juventud,
  células, partes del cuerpo enfermas y sanas, órganos, pensamientos,
  habilidades, ideas, libros, objetos, nuestros papás, familia,
  plantas, animales conocidos y desconocidos, problemas, negatividad, etc...,
  para bajar cosas, para dormirnos y soñar... con sueños lúcidos...,
  para fantasmas, para que nos salgan o no, para ver la tele, radio o música,
  valdrá la pena aprender   para qué nos servirá y para qué será grandemene inocuo.
  Prepararnos para una cosa tendrá diferente connotación que para
  otra, y debemos tener preparación individual para cada una aunque
  después hagamos las cosas más o menos colectivamente.

  Hasta podemos prepararnos para cosas negativas, para hacerlas
  más positivas, suspenderlos hasta estar preparado específicamente
  para ellas.

  Ya que esto tiene base instintiva, libre e intuitiva, natural,
  prepararnos de esta forma será como prepararnos para una carrera,
  un estudio formal, manteniéndonos frescos y filos, con buena
  práctica, para hacer esas cosas o estar con esa gente.

  Nuestra intención es estar en la mejor y más limpia condición,
  más dinámicos, descansados y con entusiasmo, haciendo lo mejor
  que tengamos para lograrlo (bañarnos, lavarnos los dientes, etc.),
  lo más funcional que realmente nos sirva para estar mejor, para
  prepararnos para estar en contacto directo con algo o alguien,
  mientras tanto estaremos solos preparándonos. Eso hará que si
  hay algo que ofrecernos mutuamente se dé de forma óptima, de acuerdo
  a lo que la situación realmente tenga para permitirnos hacer.

  Debe ser sincero y realmente interesarnos en algo.

  Simplemente cada vez que queramos hacer algo pero no
  estemos preparados, pensar con expectativa en prepararnos
  para hacerlo ya, tan rápido como podamos, pero con
  preparación total.

  Podemos considerar todo y después decidirnos por habernos
  preparado para las cosas que más logramos arreglar y que
  más energía tienen actualmente.

  Lo importante de esto es que nos permitirá prepararnos para
  lo que realmente nos interesa, y mientras tanto tener un marco
  por demás válido para dejar todo lo demás suspendido, si no
  tiene importancia para nosotros, simplemente no nos prepararemos
  para esto... hasta podemos prepararnos para revisitar problemas
  pasados en persona y cultivar lo que no debería haberse debilitado
  en nosotros.
Aunuqe no sepas del todo lo que está pasando, de esta forma
detectando dón de está la parte más accesible del programa,
hasta respirando diferente, mayormente conservando la esencia
vital del aire sin sacarla, solo al aire viciado,
fomentaremos el que no se nos olviden ideas ni sueños
cuando nos despertamos, y encontrar las partes más
importantes de un sueño... bostezar sí pero anular
cualquier pérdida o distracción al exhalar,
minimizarlo excepto en el nivel donde nos deshacemos
de una enfermedad.


  También podríamos retener, concentrar y dejar que
  la situación misma suelte la preparación para que
  todo sea óptimo en ahorrar y usar cuando se necesite.

  Acumular los deseos que REALMENTE tenemos en broma
  o de verdad, para alinearnos en lo que estamos haciendo.


* Tenemos que aprender a platicar con la computadora y
  agregarle mensajes a las partes de código que entendamos,
  que más nos interesen también, preguntarle de forma verbal
  en nuestra mente al programa, escribir de hecho las preguntas
  en partes del código, y poco a poco reubicar esas preguntas
  donde corresponden.

  Así no nos aburriremos de agregar mensajes secuencialmente
  a todo el código empezando en partes arbitrarias que podríamos
  no entender, aunque si no tenemos preguntas ni iniciativa esto
  nos mantendrá trabajando y obteniendo ideas, pero esto hará que
  lo que intentemos estudiar se potencie .





* El X-0 nos indica que el principio de
  la secuencia lógica de las cosas que queremos
  sentir y hacer cuando nos concentramos o
  desconcentramos, es cuando tenemos que hacer
  esas cosas, soltar lo que queremos pensar.

  Además, muchas veces se nos ocurre una cosa concreta
  y después la idea en la que se basa, primero el final
  y después el inicio.

  Encontrado después de haber pasado una tarde tapando
  la jugada esperada al inicio y final en el X-0 de 4
  tableros, con lo que me dí cuenta que probablemente
  ya se me está acabando el calor del X-0 que obtuve
  inicialmente, y voy a tener que volver a jugar en serio
  nivel por nivel para reencender toda la estructura
  mental óptima que obtuve inicialmente con eso.




Elementos Comunes a Buscar Intuitivamente para Programas.

¿Y si hago un subforo paranormal igual que psipog y paso lo que hay ahí mayormente
con mis propias palabras e intentos?







* NO DEJAR QUE NADA NOS INTERRUMPA,
  ni pensamientos aparentemente relacionados,
  sino que hacer todo lo que tengamos por hacer
  de forma ininterrumpida.


Decidir qué hacer, entender, poner atención,
antes de empezar a trabajar...









2017-08-01 (Miércoles)
-----------------------

Documentar todo en la computadora con la visión
de que quede explicado globalmente paso a paso
como para sistemas operativos, como para reimplementar
todo por mi cuenta. Con ese nivel de detalle y secuencia,
con ese estilo de ver y grabar las cosas.



Voy a necesitar aprender a programar el Atari 2600,
hasta saber qué estructura tiene un programa, en instrucciones,
registros, resolución, forma de programar todo el hardware,
como para poder hacer programas libremente para el Atari.
Lo bueno es que el Atari obligadamene es una máquina
multimedia, así que realmente va a enseñarme a hacer juegos
y cosas similares. Para cualquier cosa que quiera programar
de forma emulada, realmente dudo que sepa lo que está realmente
pasando si no la he programado antes a un nivel con cierta
complejidad, peso y conocimiento importante de trucos.
Con lo que me ha costado implementar un emulador extremadamente
parcial de la PC x86, solo con 16 bits hasta ahora, puedo
considerar que será muy difícil entender todo sin pasar un buen
tiempo programando otras máquinas como el Atari 2600 como para
entender lo que pasa y tener ideas propias de cómo hacer un
espejo emulado del aparato y la lógica, así que en este punto
eso necesito para entender cómo funciona cualquier emulador de
Atari 2600. Puedo seguir estudiando el programa, pero el entender
la documentación que escribe automáticamente solo va a pasar hasta
que realmente sepa cómo programar el Atari 2600 y hacer juegos,
para tener la perspectiva suficiente para entender toda la lógica
del emulador.





* Si un programa necesita de lenguajes específicos,
  en vez de la matematicidad del Ensamblador para hacer
  lo que hace, es posible que dicho programa o capa
  se valga realmente de las características de ese lenguaje
  más que cualquier otra cosa, puede haber sido concebido
  junto con el lenguaje a nivel conceptual.

  Así que no es que otros lenguajes sean más portables,
  sino que simplemente hay cosas para las que están
  explotando al máximo las características de dichos
  lenguajes. En Ensamblador solo necesitaríamos describir
  esas características como microinstrucciones de lógica pura,
  reflejando lógica, para implementar las mismas cosas de forma
  igual de portable, con características integradas de esos
  lenguajes, y con esas microinstrucciones de otros lenguajes
  escritas puramente en Ensamblador, podremos alcanzar no solo
  una cosa en particular, sino que todo lo específico a un
  lenguaje.

  Pero a lo que voy es que generando un libro automático
  se rompe el nivel de cualquier lenguaje y la naturaleza
  verbal de mostrar todo paso a paso, repetitivamente, es ideal
  para reimplementar en Ensamblador, de inmediato.

  Otro problema es que el público se ha empobrecido en la
  computación porque absolutamente nadie del público en general
  ha quedado con una experticia igual o mayor que la de los
  autores de libros de los 90's, y por lo tanto nadie les dio
  continuidad. Es algo que hay que revertir, hacer más fácil y
  completo a nivel educativo gratuito.










Es como si cada parte, órgano o estructura especializada de
mi cuerpo quisiera unirse a lo que estoy haciendo, no solo
el cerebro, así que voy a tener que darle un reloj a cada uno
de ellos, a cada idea mayor de actual interés, a cada problema
(sostenido realmente en recursos personales que realmente quieren
contribuir conmigo), a cada inquietud, a cada recurso de interés
accesible, inaccesible, interno, externo.

Igual que con el reloj de las uñas, puedo asignarle una tarea
a cada una de esas cosas, con un ciclo de trabajo que durará
hasta que algo de esa cosa o aspecto cambie de forma importante
como para cambiar y aumentar mi panorama personal, para ver
cuánto logré de esa tarea, y probar con otra tarea.


Algunas de estas cosas tardarán mucho, otras serán persistentes,
de inicio y fin, de repetición rápida, en el plazo corto,
hasta minutos o días, así que esos van a ser pulsos de control
para ciertas cosas, pero el final del ciclo será cuando algo
de ese aspecto o cosa como sistema total cambie de forma
importante. De ahí que siempre servirá de reloj.










* Para hacer siquiera posible la programación continua
  e ininterrumpida de nuestro sistema operativo, tenemos
  que agregarle cosas sin errores a nuestro kernel todo
  el tiempo, como si fuera una obra de arte.

  Truco que aprendamos sin errores ni dudas, es truco que
  agregaremos a nuestro kernel, y si hay dudas, agregarlo
  a la librería loca (AppRoach) del kernel y la de otros
  proyectos (podría ser la misma librería loca para todos
  los programas que haga).

  Con eso NUNCA voy a dejar de programar a nivel de kernel.
  Realmente así hacía las cosas inicialmente, hasta hacía
  comentarios adornados para hacer logos y otras cosas,
  y esa actitud hacía que fuera siquiera posible seguir agregando
  código bueno hasta en el tiempo cuando no sabía mucho, y ese
  código de años pasados de mis kerneles es el que estoy usando
  en casi todos los casos actuales para completar las funciones que
  me hacen falta y que ya había implementado bien en el pasado...
  ahora solo las termino de limpiar y mi kernel se vuelve un
  gran proyecto.






  Aprender a crear archivos y escribirlos en Ensamblador
  con la WinAPI para ver la secuencia de mis programas.









* El concepto de libros de programación ha sido reemplazado
  de libros con las raíces clásicas y actualizadas, por libros
  que solo hablan de lenguajes de programación superficiales;
  ha reemplazado el significado de puertos por conectores en lugar
  de puertos I/O y su significado en el hardware; el concepto de
  protección y sistemas operativos por librerías interminables de
  software cerrado que no dejan acceder el hardware directamente ni
  explican cómo funciona, es cada vez más cerrado y solo en manos
  de fabricantes.


* El problema es que solo porque las computadoras actuales tienen
  muchísima más capacidad que las anteriores, no significa que
  por eso no sea mejor usar solo la base más básica pero optimizada
  y completa desde el punto de vista lógico y que hay que pensar
  para que realmente quede como algo que no se podría implementar
  mejor independientemente de la capacidad de la computadora en donde
  corra un programa como lógica en sí.




* Ha de haber un grupo maestro de recursos e información
  para alimentar y explicar todo el código abierto, y eso
  es lo que tenemos que encontrar.



* Por ejemplo para el X-0 de 4 tableros u otros
  juegos de Atari, ver qué variables y cosas usa
  para por ejemplo mantener la posición en el
  tablero, y usar esas mismas cosas para
  desplegar un tablero diferente pero
  internamente controlado por el código del
  juego original del Atari (hacer que la nueva
  interfaz gráfica reaccione a las mismas
  variables que el juego original).



* Hacer accesible la programación e información
  aplicada a todos los niveles de forma inmediata,
  con solo usar la computadora, todo basado en
  correr programas, y que sean estos los que nos
  traigan la información al correr, que es la forma
  en la que podremos obtener todo tipo de información
  aplicada de forma inmediata, y desde ahí podremos
  entender cualquier otra cosa más teórica después de
  ver cómo funcionan los programas finales de ese
  mismo tipo de teoría.



* Aprovechar los apretujones de tiempo de cuando estamos
  esperando cosas importantes, como que traigan diarios,
  que venga un paquete, que se haga lunes o sábado, que se
  haga año nuevo, cualquier cosa que sintamos que no avanza.
  Eso hará que aprovechemos de forma más sólida y enriquecida
  el tiempo.

  No usar el tiempo de avance de un proyecto en sí mismo porque
  entonces nos bamos a trabar, ya que estamos midiendo una cosa
  en base a sí misma, como tratar de mover una carreta sin poner
  los pies en el suelo en un lugar totalmente plano y escabroso,
  muchísimo más difícil de lograr solo con impulso propio
  que si usamos otro apoyo, en este caso un momento que a todos
  les interese para avanzar en los puntos de espera.

  Afortunadamente los momentos de esperas son infinitos.



















EOF
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2945
Registrado: Sab Nov 10, 2012 1:04 pm

2017-08-24 -- Resulados del Ciclo

Notapor ~ » Jue Ago 24, 2017 9:19 am


2017-08-12 (Sábado)
-----------------------

Agregar código específicamente a nuestro kernel
y a snippets de prueba a la par de lo que hacemos
para crear SourceDocs. O sea que a la par de lo
que aprendamos, lo que aprendamos irlo agregando
a nuestro propio código limpio. Esto le dará
más cuerpo a nuestro trabajo y hará que nos
distraigamos menos.

Agregarle los comentarios y mensajes normales
a los SourceDocs, si son ventanas, tomar
capturas de pantalla.

Necesitamos hacer que lo que implementamos
se logre tan rápido como la imaginación,
aunque para eso necesitamos desarrollar
tecnología igual que con los SourceDocs.




Mantener siempre una memoria numérica compleja
para que se nos vuelva cada vez más accesible la
habilidad matemática.






2017-08-17 (Jueves)
-----------------------

Como en este ciclo de trabajo he aprendido una técnica
que me permite aprender todo lo que tenga que ver con cualquier
programa, de forma inmediata, puedo implementar mis ciclos
de trabajo en 2 partes, una teórica, de investigación, aprendizaje,
documentación y programas de snippets de prueba, y la otra parte
para agregar más código y funciones a mi kernel y
crear aplicaciones para problemas del mundo real con complejidad
formal.

Ya que este es el primer ciclo de trabajo en el que obtuve
la técnica de convertir los programas ejecutables en SourceDocs
capaces de UTF-8 y HTML5, desde cualquier lenguaje o programa existente,
y ya que en este ciclo todavía estuve trabajando de forma
poco estructurada, con un poco de teoría y práctica,
y ya que mi eficiencia fue muy baja, voy a hacer la otra mitad
de este ciclo de trabajo para trabajar en aprender de forma masiva cosas,
y en paralelo, mientras oigo un programa, implementar otra parte
de mi kernel, y de mi kernel a mis otros proyectos.


El código fuente es como un documento comprimido
con lógica humana. Para descomprimirlo se necesita
acción humana, el humano mismo es el descompresor
del documento en cuestión que explica cómo hacer
lo que hace el programa. Sin eso toca recrear el
código, pero aprenderlo sin ayuda es un trabajo
tan o más extenso que los programas existentes,
no vale la pena tratar de hacer eso siempre y cuando
haya programas del mundo real con código fuente
que podamos compilar y convertir en documento
mientras este se ejecuta, haciendo que los genere.



Cuando hagamos cualquier cosa, también buscar videos
de cómo hacer eso. Un canal así se verá raro, vano,
con poco valor, pero servirá como una librería
de microinstrucciones/OPCODES humanos, del más simple
al más rápido.

Pero así podemos darnos un impulso muchísimo mayor,
de poca a mucha inercia.

Por ejemplo buscar en modo de idioma neutro,
"Program the Sound Blaster DMA Half Buffer".

Y después sentirnos bien viendo cómo llenamos nosotros
cualquier vacío, viendo lo que existe actualmente,
y viendo lo que aprendemos al comparar nuestras acciones
con las de otros JUSTO CUANDO LAS HAGAMOS, no antes
ni después, sino que A LA PAR.


Convertir palabras normales cada vez más a
términos, conceptos, etc., técnicos, cualquier
conversación, a ver a qué programa se parece...
convertirla hasta en código fuente.....



Para lo que tiene un libro y para lo rápido que es
escanear con un escáner portable (como 75 páginas
en menos de 1 hora) vale la pena escanearlo así
de rápido para hacer eficientemente usables a los libros,
aunque queden un poco pandos, aunque se vean como que
estvieran escritos a mano.

Los únicos libros que valdría la pena escanear
normalmente con la mayor calidad y tardanza de un escáner normal,
son los libros más valiosos que tenemos, pero el
resto, que tienen un poquito de información aquí y allá
y que no son los propios de nuestra niñez,
que siempre nos han acompañado, vale la pena escanearlos
solo para convertirlos en audio usable, estudiable, en pocas
horas de empezar a escanearlos.

Eso también va a permitir distinguir qué libros son
más valiosos que otros desde un punto de vista
básico.












2017-08-18 (Viernes)
-----------------------

A la par de nuestro estudio y comprensión de cosas
nuevas cuando nos esforzamos por entender una porción
de código, tenemos que escribir la documentación de
este en SourceDocs para darle máxima eficiencia a nuestro
intento de entender.






2017-08-20 (Domingo)
-----------------------

Disftutar toda la vida se siente como que disfrutamos
hasta raspar la sensación de antes de todo lo que hacemos,
pensamos, ideamos......






Los programas grandes con código fuente ya están altamente
optimizados para el compilador, así que podemos usarlos para
agregar nuestros propios programas ahí como subprogramas para
aprovechar eso, agregar nuestro propio kernel, librerías,
y terminar agregando código para autodocumentación de SourceDoc,
.



Así que en vez de hacer nuestros programas simples, sería mejor
empezar a hacerlos dentro de otros programas, para aprender a
compilarlos y no tener que cambiar entre contextos demasiado simples
(el de nuestros programas) y el de los programas que queremos
documentar, estudiar, .



Dos ciclos en 1, uno un poco automático, y otro práctico.





2017-08-21 (Lunes)


Necesito combinar iterativamente cambiando entre tareas
de estudio lo que tenga que ver con multitareas,
administración de memoria, paginación y la WinAPI.

Desde esas metas puedo partir hacia cualquier otro
punto pero siempre aprendiendo detalles en segundo
plano y de formas indetectables hasta el último
momento para avanzar en esas cosas.





Tengo que darle acceso directo al hardware
para el usuario. Este sabe lo que hace,
lo que puedo hacer es preguntarle al usuario
si quiere dar acceso a esos dispositivos.

La emulación del hardware 100% estándar de cada
tipo debe ser perfecta para seguir siendo capaz de
usar la simplicidad y potencia de la PC.

El usuario podría usar aplicaciones bloqueantes,
pero si es el usuario y si es un programador
interesado en aprender sobre hardware, debe saber
cómo hacer las cosas para correr solo la aplicación
bloqueante mientras programe el hardware directamente.

Podríamos proveer los detalles del hardware crudo
al desactivar la emulación.




Cualquier cosa que hagamos apoyándonos en lo que
estemos usando como el reloj para un ciclo de trabajo,
para proveernos memoria, fuerza, ideas/creatividad,
o lo que sea, nos sale gratis en esfuerzo y energía,
por alguna razón.

Por ejemplo usar el sistema, las células de generación
de uñas, y estas mismas, para acordarnos de algo antes
de usar la computadora (ya que a partir de Windows 7
nos hemos vuelto a quedar sin computadora a nivel lógico).

De ahí podemos propagar inmediatamente el esfuerzo a
nuestra forma normal de hacer las cosas, fuera del marco
de los ciclos de trabajo.




Ciclos de trabajo que se tarden minutos, uno tras otro,
para lograr cosas.



slackware old versions





Hay que sentir cosas como cómo funciona Windows.
Necesitaremos aumentar esta habilidad, la sensibilidad,
para poder aprender cosas a medida las usamos,
y enumeramos sus componentes físicos, lógicos,
de acciones y procesos de producción.

Pensar activamente, profundamente, complejamente
para todo como que fuera X-0 de 4 tableros.

Pensar en cómo hicieron para lograr algo,
pensar cómo hacerlo nosotros,
usar el reloj del ciclo como base de memoria,
recursos, etc., para concentrarnos
en las cosas que queremos lograr aprender
y que queremos que formen parte de nuestros instintos.




Los títulos de la Wikipedia son cosas independientes de idioma.






En vez de solo anotar ideas para que no se me
olviden, puedo procesarlas en la base de reloj para
un ciclo de trabajo para así inyectar más de mi
vitalidad y hacer que también regrese vitalidad pasada
física y mental hasta que rebose y no deje que vitalidades
negativas externas ingresen a mí (en parte de fantasmas,
microbios, etc...).



La vida podría estar hecha por niveles, desde lo estrictamente
vivo y base, hasta lo que debería estar vivo, lo que necesita
inyección de energía, nutrientes y dinámica para estar o
considerarse vivo, y lo estrictamente muerto.

¿Cómo se vería el cuerpo si solo dejáramos las estructuras estrictamente
vivas y que deberían estar vivas, que son la base de todo?






2017-08-23 (Miércoles)
-----------------------------


Resultados del Ciclo

En este ciclo logré sobre todo obtener la técnica de crear SourceDocs de cualquier programa existente y compilable mientras este se ejecuta, lo que me permite aprender muchísimo. También obtuve las ideas básicas de cómo implementar la administración de memoria, paginación, drivers del bus PCI, sistemas de archivo FAT y en general, y el resto de drivers y características; multitarea, multihilera, etc.: Simplemente incluir las tablas completas, como las de paginación, ya precalculadas, e incluir las imágenes de los programas a cargar ya de forma estática en el kernel, como las aplicaciones que siempre se cargarán de forma predeterminada, aunque ya incluidas en una misma imagen, que parece ser una buena plataforma. También logré obtener un kernel mínimo con consola, teclado, carga de programas desde diskette con capacidad de importar funciones del kernel, mayor precisión de funciones de tiempo, capacidad de apagar los periféricos estándar (VGA normal y discos IDE) antes de apagar la computadora para no maltratar el hardware. Ese es el marco estrictamente mínimo para implementar una base de sitema operativo que permita hacer algo (pantalla de texto, teclado, consola, carga de programas, comandos internos, todos con capacidad de parámetros de línea de comandos), capacidad de cargar el sistema desde DOS y salir de vuelta hacia el DOS, y capacidad de apagar la computadora con un comando que ponga a dormir todo el hardware, empezando por los discos duros giratorios y la pantalla. Ahora lo que necesito es ver cómo puedo hacer para averiguar qué tipo de marco necesito para poder agregar cosas más avanzadas y que realmente yo necesite. Lo primero que voy a hacer es empacar un sistema operativo que realmente contenga TODOS los programas que yo quiera correr. No importa que tenga que recompilar el kernel para incluir los programas que piense correr en un día de trabajo dado, pero así voy a empezar a agregar administración de memoria, multitarea, todos los programas y drivers que de verdad me van a ayudar a avanzar, y voy a empezar con un sistema operativo totalmente monolítico, que incluya tanto los programas como el sistema operativo mismo en un único binario, que es un formato por demás ideal para cosas hechas y destinada en casa, para un usuario individual, para suplir mis propias necesidades y de los que tengan las mismas necesidades e intereses, igual que los aparatos simples de juego de los 90's como Magic Trolls, o cualquiera de esos aparatos de displays LCD para jugar, o el Math Pet. Otra cosa que he visto es que no tengo que soltar el teclado cuando se me olvida qué escribir, y en vez de buscar papel y lápiz o la computadora, tengo que escribir en la base de reloj del ciclo lo que quiero hacer, y procesarlo ahí, ya que ese es el medio más rápido para trabajar. Actualmente todos los sistemas operativos son demasiado lentos como para trabajar masivamente hasta cuando ya están plenamente cargados debido a cómo están implementados los programas, con un nivel cada vez más grande de ineficiencia. Realmente se ve que si algo no puede correr o tiene problemas para correr en una 386, también se va a degradar en computadoras superiores, así que se ve que la tecnología de la PC x86 solo es ideal para usar lenguajes de bajo nivel, Ensamblador y optimzaciones a mano y automáticas que realmente entendamos, con código breve, casi exclusivamente, y a lo sumo C o C++. Más allá de eso si usamos algo más complejo que JavaScript, a partir de Java, todo se va a empezar a degradar, desde la velocidad de las aplicaciones, y el sistema será inutilizable por lo mucho que se trabará... será como no tener computadora, sin importar todas las funciones que el sistema incluya. Tengo que empezar siempre a trabajar por lo más difícil, confuso y desconocido, y después agregar las cosas que ya tengo listas. Eso hará que todas las cosas caigan por su propio peso. Al hacer lo más difícil primero, cargo todo el entorno de trabajo para usar algo parecido a energía potencial (nuevas estructuras básicas para trabajar, que de hecho es nuestro suelo inicial para siquiera poder hacer cualquier cosa), y una vez que lo más difícil se detecta como algo que no tiene sentido, como algo puramente teórico, ahí es donde le vamos a agregar lo que nos resulta fácil. El concepto de tedio a la par de difícil confuso y desconocido es una trampa lógica que debe eliminarse. O sea que no tengo por qué considerar el concepto de tedio cuando trabaje en mi kernel, mis proyectos o lo que sea que haga, cuando vea cosas de diversión etc... No sé para qué me pueda servir el concepto de tedio, tal vez solo serviría para que entienda la calidad de lo que alguien más ha hecho cuando mencione que algo es tedioso, pero sobre todo para ver cuánto han sufrido los proyectos de esa persona por la trampa lógica del tedio versus lo difícil, que es algo a descartar siempre, y que simplemente hay que hacer mejor, más limpiamente y de forma 100% estándar para destruir de verdad esa trampa lógica. El sistema operativo tiene que tener una estructura de diseño modular del software como los chips de la 8088 para que sea fácil de entender y después que eso haga fácil armar tarjetas madre, con una lógica y estructura físicamente idénticas entre software y hardware de PC estándar. Tal vez Windows está hecho así, es capaz no solo de compilar el kernel sino que también compilar tarjetas madre y tarjetas ISA, PCI y USB con la misma base de código. Tal vez la forma en la que sería ideal escribir programas en lenguajes de alto nivel sería escribirlos originalmente en ese lenguaje y después reimplementarlos totalmente en Ensamblador, así el código de alto nivel solo sería un esquema capaz de ser compilado, pero no sería el código ni framework que usaríamos, sino que simplemente esa mismísima estructura, tanto del idioma como de los algoritmos, simplemente en Ensamblador a mano o con un compilador capaz de generar código realmente breve y nativo. Generar y usar combinaciones de valores constantes comunes y capaces de generar todos los rangos que necesitemos para hacer más práctica y simple la programación en Ensamblador. También aprendí que la mejor forma de tomar agua es tomar y después respirar profundamente reteniendo el aire para máxima absorción de oxígeno, que necesitaremos cuando el agua llegue a la sangre y cuando esta se expanda ya estará lo suficientemente enriquecida en oxígeno como para hacernos sentir bien en vez de asco o mareados, por tomar agua adecuadamente, el volumen de sangre en agua diariamente. Para terminar de concentrarme, veo que con todo el spam mental que me ronda simplemente tengo que seguir esperando clics de ocurrencias sin hacer sobreesfuerzo de procesamiento. Para acordarme de los sueños veo que la negatividad, ahora con spam mental, me espera tan pronto me despierto, y frecuentemente cuando todavía estoy soñando. Pero veo que no tengo que preocuparme. Simplemente tengo que esperar entrar en contacto normalmente con las cosas que me gustan y que se me empiecen a ocurrir ideas, sin preocuparme de problemas sin sentido como el spam mental, y así puedo reentrar en mis propios canales mentales sin tener que pasar por canales externos de spam. Para los sueños, puedo desarrollar diferentes técnicas como quedarme con objetos, en los entornos, con frases y palabras, y anotarlas ya que el cerebro parece, sino descartar, cambiar de nivel mental y encubrir el contenido de los sueños después de unos minutos, días o meses, si no los mantengo en uso en mi entorno infinito. Para las cosas de diversión, simplemente tengo que disfrutar sin reprocesar a través de canales de spam, como siempre, como se le ocurra a mi cerebro, y como antes. En conclusión, en este ciclo logré planear de forma efectiva, práctica y conceptual, cómo implementar la administración de memoria, la paginación, la multitarea, los sistemas de archivos, los drivers PCI, todos estos y otros mediante tablas preprogramadas. También logré entender que tengo que aprender a compilar cada vez más programas de snippets y los que normalmente uso para convertirlos en SourceDoc mientras se ejecutan y con eso tener la mejor información directamente de la computadora, directamente del programa, trabajando como profesor automatizado del que solo tengo que descomprimir manualmente, lógicamente, humanamente, la lógica contenida en el código, hacia documentos de CHMEmulator, imágenes, y cualquier otra cosa que necesite. funcionando trabajando Con eso ya puedo lograr sumergirme mucho más que antes a aprender cosas no de tutoriales que no son del todo funcionales (cuando no tienen programas de muestra o hasta cuando los tienen pero que no son programas que resuelven de forma completa y profesionalmente compleja problemas del mundo real con el nivel necesario por la industria de software y hardware; ahora con esto sí puedo estudiar y aprender a ese nivel desde el principio). Y otra cosa que creo que voy a hacer es separar mi sistema operativo en por lo menos 2 líneas de desarrollo. La normal, la que desarrollo a nivel de pruebas, prácticamente solo para mí, se podría seguir llamando ArcheFire, pero la línea de las versiones finales de nivel globalmente final la podría llamar Siam, así como se llamaba la línea de Firefox para desarrolladores Aurora. Aunque ambos deben ser igual, y competitivamente excelentes en claridad de código y servir como recursos de educación. branches ramas líneas
EOF
Imagen
IP for hosts file (email udocproject@yahoo.com to get updates if website becomes offline):
Código: Seleccionar todo
190.150.9.244 archefire.org



See what I'm doing in real time:
Main Desktop 1
Main Desktop 2
Avatar de Usuario
~
Site Admin
 
Mensajes: 2945
Registrado: Sab Nov 10, 2012 1:04 pm


Volver a Ciclos de Trabajo

¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 30 invitados


cron