_AltComp_

Como nota inicial, si alguien no tiene una mejor idea de cuál sería la mejor forma de que escriba varios posts como respuestas seguidas, incluso quizás después de varias semanas, pido disculpas si envío respuestas a este tema o abro otros nuevos, porque seguramente va a ser mucha la complejidad a manejar, y repartir las diferentes etapas de descubrimientos es mucho más fácil repartiéndolas en diferentes posts, temas y/o respuestas (que serían continuas a menos que alguien responda o consulte algo, o tenga una idea de qué más averiguar o hacer algo interesante y útil con todo esto desde ya, aparte obviamente de realmente aprender Java). Me tomo la libertad de escribir sobre la programación en ensamblador, pero en el lenguaje dictado por el bytecode de Java. Las razones más importantes de esto son: - Para personas demasiado acostumbradas a trabajar con lenguajes al nivel de C o más bajos, trabajar con un ensamblador en un entorno nativo a la orientación a objetos hace mucho más fácil entender a cabalidad cómo funciona realmente la orientación a objetos, en este caso, de Java. - Dado que Java es una plataforma unificada sin importar el hardware sobre el que corra, estudiarlo a nivel de ensamblador es una oportunidad excepcionalmente buena para practicar la ingeniería inversa y obtener un nivel de experticia por lo menos intermedio. - Siendo expertos en el ensamblador de Java y en el formato de archivos de bytecode (.class), así como en el uso de las diferentes APIs y teniendo experticia suficiente para escribir un compilador no optimizador como mínimo, se puede dejar de usar el lenguaje Java para producir programas de Java, y eventualmente es posible usar virtualmente cualquier otro lenguaje de programación (incluso ensamblador de Intel x86, e incluso enmascarando las APIs de Java para usarlas como "alias" de otras plataformas como WinAPI o JavaScript, y así "recortar" un poco lo que se necesita aprender, y unificar un mismo conocimiento en diferentes ambientes de desarrollo). Esto puede llegar a ser especialmente útil, porque significaría que muchos programas escritos lenguajes que tradicinalmente tienen poca o ninguna portabilidad entre plataformas de hardware pueden reutilizarse, convirtiéndolos en instrucciones de bytecode de Java. - El ensamblador de Java es extremadamente valioso. Los lenguajes de ensamblador "normales" son evitados por la mayoría de programadores no solo por su complejidad, sino que por el hecho de que no están pensados para ser portables. Con Java, los programas generados son más simples que los ejecutables ELF de Linux, y el ensamblador que se escriba en una plataforma, puede correr en cualquier otra en la que haya una JVM. Eso significa que se pueden hacer tareas interesantes de muy bajo nivel, que al mismo tiempo incluyan programación "moderna" orientada a objetos, con la posibilidad de poder seguir corriendo el mismo código en otras plataformas. Todo esto suena muy interesante, pero para lograrlo, siendo indistintamente buenos programadores de C/ensamblador por ejemplo, o buenos programadores de Java (aunque a un nivel común y corriente, no a nivel de ensamblador y de la arquitectura central), este proceso puede llevar no menos de un año, durante el que hay que releer cosas como el Tutorial de Java, compilar los programas de ejemplo, hacer ingeniería inversa intensa y desensamblarlos (NO decompilarlos, sino que inspeccionar los archivos binarios a mano si es posible y/o hacer un parser), y leer una y otra vez las partes de las especificaciones que se están aplicando en cada ejemplo compilado. ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ Pongo un ejemplo simple de un Hola Mundo, como el del Tutorial de Java, pero en Ensamblador de Java. No he usado un ensamblador nativo de Java "apropiado" sino que NASM, que entre otras cosas no permite usar Big Endian (Java) sino solo Little Endian (x86), así que se ve rápidamente la necesidad de usar un programa ensamblador ya sea de ARM que use Big Endian por defecto, crear un ensamblador propio para Java (en JavaScript por ejemplo), o buscar un ensamblador "apropiado" nativo a Java. Esto debe compilarse con lo siguiente, ya sea en Windows, Linux, etc.: nasm EHLOWorldApp.asm -o EHLOWorldApp.class ;/***************************************************************************** ;EHLOWorldApp.java ; ; 2012-07-02 ; ; ;Demostración inicial de un programa de Java escrito totalmente en ensamblador ;(ensamblador de Java, pero usando NASM para codificar los bytes). ; ;http://devel.no-ip.org/ ; ;Este código es de dominio público (sin derechos de autor). ;Puedes hacer lo que desees con él. ; ; ;*****************************************************************************/ _CLASS_START: _00000000__magic db 0xCA,0xFE,0xBA,0xBE _00000004__minor_version dw 0x0000 _00000006__major_version db 0x00,0x33 _00000008__constant_pool_count db 0,29+1 _0000000A__cp_info_0001: db 0x0A ;cp_info.tag: CONSTANT_Methodref db 0,0x06 ;cp_info.info.class_index db 0,0x0F ;cp_info.info.name_and_type_index _0000000F__cp_info_00002: db 0x09 ;cp_info.tag: CONSTANT_Fieldref db 0,0x10 ;cp_info.info.class_index db 0,0x11 ;cp_info.info.name_and_type_index _00000014__cp_info_0003: db 0x08 ;cp_info.tag: CONSTANT_String db 0,0x12 ;cp_info.info.string_index _00000017__cp_info_0004: db 0x0A ;cp_info.tag: CONSTANT_Methodref db 0,0x13 ;cp_info.info.class_index db 0,0x14 ;cp_info.info.name_and_type_index _0000001C__cp_info_0005: db 0x07 ;cp_info.tag: CONSTANT_Class db 0,0x15 ;cp_info.info.name_index _0000001F__cp_info_0006: db 0x07 ;cp_info.tag: CONSTANT_Class db 0,0x16 ;cp_info.info.name_index _00000022__cp_info_0007: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x06 ;cp_info.info.length db "<init>" ;cp_info.info.bytes _0000002B__cp_info_0008: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x03 ;cp_info.info.length db "()V" ;cp_info.info.bytes _00000031__cp_info_0009: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x04 ;cp_info.info.length db "Code" ;cp_info.info.bytes _00000038__cp_info_000A: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x0F ;cp_info.info.length db "LineNumberTable" ;cp_info.info.bytes _0000004A__cp_info_000B: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x04 ;cp_info.info.length db "main" ;cp_info.info.bytes _00000051__cp_info_000C: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x16 ;cp_info.info.length db "([Ljava/lang/String;)V" ;cp_info.info.bytes _0000006A__cp_info_000D: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x0A ;cp_info.info.length db "SourceFile" ;cp_info.info.bytes _00000077__cp_info_000E: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x11 ;cp_info.info.length db "EHLOWorldApp.java" ;cp_info.info.bytes _0000008B__cp_info_000F: db 0x0C ;cp_info.tag: CONSTANT_NameAndType db 0,0x07 ;cp_info.info.name_index db 0,0x08 ;cp_info.info.descriptor_index _00000090__cp_info_0010: db 0x07 ;cp_info.tag: CONSTANT_Class db 0,0x17 ;cp_info.info.name_index _00000093__cp_info_0011: db 0x0C ;cp_info.tag: CONSTANT_NameAndType db 0,0x18 ;cp_info.info.name_index db 0,0x19 ;cp_info.info.descriptor_index _00000098__cp_info_0012: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x0C ;cp_info.info.length db "Hello World." ;cp_info.info.bytes _000000A6__cp_info_0013: db 0x07 ;cp_info.tag: CONSTANT_Class db 0,0x1A ;cp_info.info.name_index _000000A9__cp_info_0014: db 0x0C ;cp_info.tag: CONSTANT_NameAndType db 0,0x1B ;cp_info.info.name_index db 0,0x1C ;cp_info.info.descriptor_index _000000AE__cp_info_0015: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x0C ;cp_info.info.length db "EHLOWorldApp" ;cp_info.info.bytes _000000BD__cp_info_0016: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x10 ;cp_info.info.length db "java/lang/Object" ;cp_info.info.bytes _000000D0__cp_info_0017: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x10 ;cp_info.info.length db "java/lang/System" ;cp_info.info.bytes _000000E3__cp_info_0018: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x03 ;cp_info.info.length db "out" ;cp_info.info.bytes _000000E9__cp_info_0019: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x15 ;cp_info.info.length db "Ljava/io/PrintStream;" ;cp_info.info.bytes _00000101__cp_info_001A: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x13 ;cp_info.info.length db "java/io/PrintStream" ;cp_info.info.bytes _00000117__cp_info_001B: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x07 ;cp_info.info.length db "println" ;cp_info.info.bytes _00000121__cp_info_001C: db 0x01 ;cp_info.tag: CONSTANT_Utf8 db 0,0x15 ;cp_info.info.length db "(Ljava/lang/String;)V" ;cp_info.info.bytes __1D: db 0x08 ;cp_info.tag: CONSTANT_String db 0,0x12 ;cp_info.info.string_index _00000139__access_flags: db 0x00,0x20 _0000013B__this_class: db 0x00,0x05 _0000013D__super_class: db 0x00,0x06 _0000013F__interfaces_count: db 0x00,0x00 ;interfaces ------- no interfaces _00000141__fields_count: db 0x00,0x00 ;field_info ------- no fields _00000143__methods_count: db 0x00,0x02 _00000145__method_info_0001: db 0x00,0x00 ;access_flags db 0x00,0x07 ;name_index db 0x00,0x08 ;descriptor_index db 0x00,0x01 ;attributes_count db 0x00,0x09 ;code_attribute/attribute_info[0].attribute_name_index db 0x00,0x00,0x00,(0x1D) ;code_attribute/attribute_info[0].attribute_length db 0X00,0X01 ;code_attribute.max_stack db 0X00,0X01 ;code_attribute.max_locals db 0X00,0X00,0X00,0X05 ;code_attribute.code_length ;INIT: Instructions ;INIT: Instructions ;INIT: Instructions ;INIT: Instructions db 0X2A ;aload_0 db 0XB7 ;invokespecial #1 db 0X00 db 0X01 db 0XB1 ;return ;END: Instructions ;END: Instructions ;END: Instructions ;END: Instructions db 0X00,0X00 ;code_attribute.exception_table_length db 0X00,0x01 ;code_attribute.attributes_count ;1 db 0X00,0X0A ;LineNumberTable_attribute/attribute_info.attribute_name_index db 0X00,0X00,0X00,0X06 ;LineNumberTable_attribute/attribute_info.attribute_length db 0X00,0X01 ;LineNumberTable_attribute.line_number_table_length db 0X00,0X00 ;line_number_table[0].start_pc db 0X00,0X05 ;line_number_table[0].line_number ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; _00000170__method_info_0002: db 0x00,0x09 ;access_flags db 0x00,0x0B ;name_index db 0x00,0x0C ;descriptor_index db 0x00,0x01 ;attributes_count db 0x00,0x09 ;code_atribute/attribute_info[0].attribute_name_index db 0x00,0x00,0x00,(0x25) ;code_atribute/attribute_info[0].attribute_length x17E: db 0x00,0x02 ;code_attribute.max_stack db 0x00,0x01 ;code_attribute.max_locals db 0x00,0x00,0x00,(0x09) ;code_attribute.code_length ;INIT: Instructions ;INIT: Instructions ;INIT: Instructions ;INIT: Instructions db 0xB2 ;getstatic #2 db 0x00 db 0x02 db 0x12 ;ldc #3 db 0x1D db 0xB6 ;invokevirtual #4 db 0x00 db 0x04 db 0xB1 ;return ;END: Instructions ;END: Instructions ;END: Instructions ;END: Instructions db 0x00,0x00 ;code_attribute.exception_table_length db 0x00,0x01 ;code_attribute.attributes_count ;1 db 0x00,0x0A ;LineNumberTable_attribute/attrbute_info.attribute_name_index db 0x00,0x00,0x00,0x0A ;LineNumberTable_attribute/attribute_info.attribute_length db 0x00,0x02 ;LineNumberTable_attribute.line_number_table_length db 0x00,0x00 ;line_number_table[0].start_pc db 0x00,0x07 ;line_number_table[0].line_number db 0x00,0x08 ;line_number_table[1].start_pc db 0x00,0x08 ;line_number_table[1].line_number ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; f_000001A3__attributes_count db 0x00,0x01 ;attributes_count ;1 db 0x00,0x0D ;SourceFile_attribute/attribute_info[0].attribute_name_index db 0x00,0x00,0x00,0x02 ;SourceFile_attribute/attribute_info[0].attribute_length db 0x00,0x0E ;SourceFile_attribute.sourcefile_index Y el código equivalente en Java normal: class EHLOWorldApp { public static void main(String[] args) { System.out.println("Hello World."); } } Planeo poco a poco documentar y explicar lo que está pasando, aunque ya que he comentado prácticamente todas las líneas en ensamblador, obviamente entiendo lo que está pasando. Aunque necesito formalizar las explicaciones, porque voy a necesitarlo cuando trate escribir un ensamblador especial para Java y cuando quiera implementar un compilador de un lenguaje que no sea Java, pero que produzca programas para Java. ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ ------------------------------------------------------ Referencias Seguir las especificaciones es relativamente fácil para quienes, como yo, están acostumbrados a examinar de forma permanente la estructura de todos los archivos en su computadora, a hacer encajar exactamente cada pieza de un programa en ensamblador (lo que permite encontrar mucho más rápidamente la causa de errores causados por dos o más valores interdependientes) y a pensar en términos de cómo las especificaciones combinan los datos requeridos para una tarea en estructuras de todo tipo (y teniendo en mente qué pudieron haber estado pensando los desarrolladores de dichos estándares para hacer las cosas de la forma en que las hicieron de entre muchos diseños posibles e incluso mucho más simplificados). Como dije, una de las intenciones principales de todo esto es eventualmente poder escribir programas de Java con lenguajes "normales", como C, Visual Basic, Pascal, etc. Pero para eso se necesita tener gran experticia en el ensamblador de Java, y en la estructura de bajo nivel del lenguaje, las clases, y todos los demás aspectos de la máquina virtual de Java, para poder crear equivalentes para hacer que de un lenguaje no oficial se pueda producir bytecode apropiado y totalmente correcto. Esta es la lista de lo que hay que empezar a leer, y no hay que olvidar tampoco las referencias de las diferentes APIs, y también el tutorial de Java, que sería extremadamente interesante "remasterizar" en su versión en ensamblador Java, para comprender cada detalle de lo que contiene y hacer posible que se convierta en un libro de alto nivel capaz de volver a un programador en un experto absoluto en Java, ya sea programando en alto nivel o en el nivel más bajo posible: Especificaciones de bajo nivel de Java El capítulo 4 habla específicamente del formato de los archivos .class Wikipedia: Formato de los archivos .class Wikipedia: Resumen del bytecode de Java Wikipedia: Resumen del conjunto de instrucciones de Java También vale la pena mencionar el comando básico del desensamblador del JDK: javap -c EHLOWorldApp.class

Este es el libro "El Habla de Mi Tierra", que trata sobre el estudio del idioma Español en gran detalle y en todos sus aspectos. Contiene 459 imágenes con resolución de 1,700px × 2,338px. Esta es la URL en la que mantengo actualizado y vigente los links de descarga en un momento dado, así como las imágenes individuales para una vista rápida: Descargar El Habla de Mi Tierra; Rodolfo María Ragucci (Actualizado el 14 de Noviembre del 2014) MD5: 345334d526b20da63c4607b231998673 Dado lo raro que es encontrar ahora literatura de esta calidad y que necesitaba preservar mi ejemplar ya desgastado por el uso y por el tiempo (incluso antes de tenerlo yo, allá por los años 70/80). Originalmente lo escaneé y publiqué, en Marzo del año 2013, como imágenes JPG sueltas para poder ser vistas fácilmente sin descargar todo el paquete y sin consumir demasiados recursos del cliente y del servidor, y ahora he subido el ZIP con todas las imágenes en link anterior.

Este es un curso corto sobre un algoritmo para calcular el calendario usando solo cálculos mentales de aritmética simple. Actualmente solo hay un video para la Semana 1, pero eso debería dar suficiente tiempo para entender cada parte del curso de una forma realmente detallada. El algoritmo es muy liviano así que es adecuado para permitir su uso y cálculos mentales con este, así que también debería ser extremadamente simple, optimizado y ligero si se usa para implementar una aplicación de administración de fecha, por ejemplo en un BIOS de código abierto o en un kernel. No se trata de calcular un timestamp sino que de los números en cuestión 1-31 y sus nombres de día de semana correspondientes. Calculando el Calendario Mentalmente. Aprendiendo la Secuencia de Días del 1 al 31. La primera cosa que necesitamos aprender para calcular el calendario mentalmente, es aprender la secuencia de los días en orden vertical. Esto nos permitirá alcanzar todas las semanas rápidamente para cualquier día, también nos permitirá obtener todos los números de días para cada día de la semana. La única otra cosa que nunca debemos olvidar es el nombre de día de semana en el que comienza el mes, y también el número de días de ese mes. Simplemente debemos memorizar eso, y normalmente es suficiente memorizar eso para el mes actual. A medida pase el tiempo, nos resultará más rutinario recordar esos detalles. Tenemos meses con 28, 29, 30 y 31 días, pero si aprendemos la secuencia de 31 días podremos calcular cualquier día de meses más cortos. La siguiente es la secuencia verbal que necesitamos aprender. Una única línea es la secuencia para un único día de semana. El mes puede iniciar en cualquier día, así que la secuencia para el día 1 o el resto de días puede caer en cualquier día de semana: 1, 8, 15, 22, 29. 2, 9, 16, 23, 30. 3, 10, 17, 24, 31. 4, 11, 18, 25. 5, 12, 19, 26. 6, 13, 20, 27. 7, 14, 21, 28. Simplemente memoriza los números anteriores y mira si puedes luego inspeccionar el calendario para el mes actual y hacer concordar esta secuencia con la secuencia para el mes en cuestión en que estás interesado. Solo hay 7 días de la semana, así que esta lista solo puede empezar en 7 formas diferentes, pero esta misma secuencia se usa siempre para las 7 combinaciones. Ahora mira si puedes determinar el primer día de semana sin ver el calendario, y también el último día. Practica con otros días a medida que los necesites. Determinando el Último Día. Tenemos meses con 28, 29, 30 y 31 días. Los meses de 28 días terminan el día de semana antes del que empezaron. Los meses de 29 días terminan el día de semana en el que empezaron. Los meses de 30 días terminan el siguiente día de semana del que empezaron. Los meses de 31 días terminan dos días de semana después del que empezaron. El primer día del siguiente mes es simplemente el siguiente día de semana para cualquiera de los últimos días de semana que acabamos de describir. Ahora mira si puedes calcular el último día de semana para este mes y luego el primer día de semana para el siguiente mes al avanzar al siguiente día de semana. Ahora también trata de calcular el día de semana de varios cumpleaños o días de semana de fechas en las que necesites terminar o pagar algo. También trata de calcular los días de semana para el Sábado o Domingo siguientes.

Semana 1/Parte 1: https://www.taringa.net/post/ciencia-educacion/19602925/Curso---Calculando-el-calendario-mentalmente-semana-1.html Parte 2 Semana 2 Calculando el Calendario Mentalmente. Calculando Libremente para Cualquier Mes. link: http://www.youtube.com/watch?v=6-G1IgHX5Vc Debemos recordar el primer día de semana del año, si es bisiesto, y la siguiente secuencia de números a continuación. Si el año no es bisiesto, debemos calcular normalmente la secuencia de principio de mes y luego restar 1, y esto aplica a partir de Febrero. Esta secuencia aplica con 0 para Enero ya que es el punto inicial, y luego desde Febrero hasta el primer día del siguiente año. Para saber manualmente si el año es bisiesto, simplemente necesitamos ver si Febrero es de 29 días. Si es de 28 días, entonces no es bisiesto. También en general, si el año es exactamente divisible entre 4 entonces es bisiesto. Esto puede no aplicar para todos los años existentes, pero es la consideración mínima que podemos determinar calculando solo mentalmente de forma simple. Debemos aprender la siguiente secuencia de números para poder calcular el día inicial para cualquiera de los meses. Cada uno de estos números corresponde a cada uno de los meses del año, desde Enero a Diciembre, y el último número individual corresponde al primer día del siguiente año: 0, 3, 5, 1. 3, 6, 1, 4. 7, 2, 5, 7. 3. Ejemplos de años bisiestos son 2000, 2004, 2008, etc. Podríamos aprender: - El número de un año especial específico. Por ejemplo 1984. - El primer día de semana de ese año. Domingo en este caso. - Y si es bisiesto al ver si Febrero tiene 29 días. En este caso sí. Solo con eso y con nuestras técnicas hasta ahora podemos ahora calcular cualquier día de ese año. Ahora trata de determinar el primer día de Noviembre y el 2 de Noviembre del 2016. 2016 empezó en Viernes, es bisiesto porque Febrero tiene 29 días. 2016 es divisible exactamente entre 4. Para Noviembre corresponde avanzar 5 días y como es bisiesto tenemos que avanzar esos 5 días en lugar de 4 días, para reflejar que el 29 de Febrero está presente. Así que como empezamos en el primer día del año: Viernes. Si avanzamos 5 días después, desde el día inicial del año, tenemos: Viernes, Sábado, Domingo, Lunes, Martes. Así que el 1 de Noviembre del 2016 cae en Martes, y obviamente el 2 de Noviembre cae en Miércoles.

Saludos. Aquí mando un curso de admisión, gratis, online, sin límite de vigencia a diferencia de la mayoría de cursos gratis online, que acabo de estudiar para tratar de entrar a una carrera técnica y aprender de cómo implementar dispositivos de hardware para PC. Es un repaso básico de Física, Matemática y Técnicas de Estudio, pero podría servir para volver a encender esos recuerdos y que ya no cuesten tanto. También pienso poner el 100% de esa carrera en línea gratis en caso de que realmente logre estudiarla, así que voy a estar mandándote las clases de esa carrera para que también te quede una copia entera de esa carrera, en videos de YouTube, escaneos en el Archive.org y otros posibles sitios de recursos. Me gustaría ver el contenido de otras carrera. Todos nos beneficiaríamos, Poner carreras enteras gratis parece no ser tan difícil pero parece ser algo nunca antes visto en internet, así que atraería mucha atención y ganancias. Una cosa que vale la pena mencionar es que en Física siempre empezamos por estudiar las unidades de medida y la conversión de unidades. También cabe mencionar que para quien sea programador, estudiar ayudándose como mínimo de programas en JavaScript e interfaces HTML para calcular y hacer herramientas para automatizar y usar las diferentes fórmulas y conceptos, es una gran ventaja.

link: http://youtube.com/watch?v=gdUipEt4WPk Link de descarga del manual (384 páginas, 100 Megabytes de JPG): http://archive.org/download/Phoenix_PC_BIOS_Books/1_System%20BIOS%20PC%20and%20EISA%202ndEd.zip Con este manual aprenderemos a programar el BIOS base de todas las PC estándar. Necesitamos saber llamar a las funciones del BIOS con ensamblador de NASM, TASM o MASM, con Turbo C++ o con inline assembly de los diferentes compiladores. Es una adición importante a referencias como la de Ralf Brown ya que muestra cada campo y servicio del BIOS base de forma limpia, proveniente de un fabricante principal de BIOS (Phoenix). Este video contiene la vista previa del video y el audio del texto completo (fue procesado a computadora con OCR de Lucion File Converter y leído a MP3 con Balabolka así que se oye exactamente lo que la computadora interpretó). El video está pensado para poder oír cada detalle que el libro contiene y así decidir si hay información especial de interés, haciendo un esfuerzo mínimo para leerlo.