En atención a lo estipulado por el Reglamento de la Ley Orgánica del ITSON en su título segundo, capítulo II, artículo 13 fracción IV y capítulo III, artículo 43 fracción VI, se presenta el informe anual de actividades, realizadas durante el período octubre 2007 a septiembre 2008.
En atención a lo estipulado por el Reglamento de la Ley Orgánica del ITSON en su título segundo, capítulo II, artículo 13 fracción IV y capítulo III, artículo 43 fracción VI, se presenta el informe anual de actividades, realizadas durante el período octubre 2007 a septiembre 2008.
Tesis de doctorado
De Giusti, Marisa Raquel; Gordillo, Silvia; Castro, Silvia; Suppi, Remo; Baldasarri, Sandra
Doctor en Ciencias Informáticas; Facultad de Informática
La enseñanza en el área de simulación de eventos discretos requiere integrar una variedad de conceptos teóricos y ponerlos en práctica a través de la creación y ejecución de modelos abstractos de simulación, con el objetivo de recopilar información que pueda traspolarse hacia los sistemas reales. Para construir modelos, ejecutarlos y analizar los resultados de cada ejecución se utilizan herramientas de software cada vez más sofisticadas que permiten expresar los elementos de los modelos en términos de entidades abstractas y relaciones, y que recopilan gran cantidad de datos y estadísticas sobre cada una de estas entidades del modelo. GPSS es una de estas herramientas, y se compone de un lenguaje de programación por bloques y un motor de simulación que traduce estos bloques en distintas entidades del modelo. A pesar de que su primera versión data de 1961, GPSS es aún muy utilizado por profesionales y empresas, y es una de las herramientas más utilizadas para la enseñanza de simulación de eventos discretos por instituciones académicas de todo el mundo.
El avance de la capacidad de cómputo de las computadoras ha permitido incorporar una mayor cantidad de herramientas y funciones a las distintas implementaciones de GPSS. Mientras que esto representa una ventaja para sus usuarios, requiere también un cada vez mayor esfuerzo por parte de los docentes para enseñar a sus estudiantes a aprovechar todo su potencial. Muchos docentes e investigadores han buscado optimizar la enseñanza de simulación de eventos discretos desde múltiples ángulos: la organización del curso y la metodología de enseñanza, la creación de elementos de aprendizaje que ayuden a aplicar los distintos elementos teóricos, la generación de herramientas para construir modelos GPSS, y la construcción de herramientas para comprender el motor de simulación por dentro.
En esta tesis se introduce una herramienta de software que permite construir modelos GPSS de manera interactiva, cuyo diseño fue pensado para integrar los elementos teóricos del curso con los objetos y entidades de GPSS. Esta herramienta también permite ejecutar estos modelos y analizar con alto nivel de detalle su evolución a través del tiempo de simulación, lo que permite a los estudiantes comprender cómo funciona el motor de simulación y cómo interactúan las distintas entidades entre sí. Se incluye también una propuesta de enseñanza basada en una fuerte participación de los estudiantes, que, por medio de esta nueva herramienta, les permite incorporar los conceptos más fácilmente. Esta propuesta de enseñanza fue puesta a prueba con alumnos del área de sistemas, quienes tomaron un curso que contiene los m
Ver registro completo en: http://sedici.unlp.edu.ar/handle/10915/29753
El uso intensivo de las TIC en los procesos educativos de las Instituciones de Educación Superior de América y latina y el mundo, ha generado cambios en la forma de producir los contenidos destinados específicamente para la virtualidad, impulsando el uso de nuevas herramientas y metodologías que apunten a optimizar los procesos de producción y con ello lograr aportes sustanciales a la forma en la que los usuarios interactúan con los recursos educativos.
La propuesta de la Dirección de Educación Virtual de la Universidad Tecnológica de Bolívar en Cartagena de Indias, Colombia da cuenta de un proceso estructurado que utiliza programas basados en software libre buscando no sólo la estandarización, sino una revolución en la forma de crear contenidos, estructurarlos y gestionarlos.
Este documento busca introducir al lector en la experiencia de la Dirección de Educación Virtual de la UTB al mostrar los antecedentes de trabajo, las exploraciones y finalmente los resultados a los que se ha llegado desde sus inicios en el año 2001.
Este trabajo se focaliza en medir el grado de adopción de las TIC en las empresas de servicios de Colombia, a partir de índices compuestos y luego investigar cuáles son los factores determinantes de la difusión de las TIC en las empresas de servicios, así como el impacto de las TIC (tanto en términos de inversión como de uso) en la productividad laboral.
Tesis de doctorado
De Giusti, Marisa Raquel; Gordillo, Silvia; Castro, Silvia; Suppi, Remo; Baldasarri, Sandra
Doctor en Ciencias Informáticas; Facultad de Informática
La enseñanza en el área de simulación de eventos discretos requiere integrar una variedad de conceptos teóricos y ponerlos en práctica a través de la creación y ejecución de modelos abstractos de simulación, con el objetivo de recopilar información que pueda traspolarse hacia los sistemas reales. Para construir modelos, ejecutarlos y analizar los resultados de cada ejecución se utilizan herramientas de software cada vez más sofisticadas que permiten expresar los elementos de los modelos en términos de entidades abstractas y relaciones, y que recopilan gran cantidad de datos y estadísticas sobre cada una de estas entidades del modelo. GPSS es una de estas herramientas, y se compone de un lenguaje de programación por bloques y un motor de simulación que traduce estos bloques en distintas entidades del modelo. A pesar de que su primera versión data de 1961, GPSS es aún muy utilizado por profesionales y empresas, y es una de las herramientas más utilizadas para la enseñanza de simulación de eventos discretos por instituciones académicas de todo el mundo.
El avance de la capacidad de cómputo de las computadoras ha permitido incorporar una mayor cantidad de herramientas y funciones a las distintas implementaciones de GPSS. Mientras que esto representa una ventaja para sus usuarios, requiere también un cada vez mayor esfuerzo por parte de los docentes para enseñar a sus estudiantes a aprovechar todo su potencial. Muchos docentes e investigadores han buscado optimizar la enseñanza de simulación de eventos discretos desde múltiples ángulos: la organización del curso y la metodología de enseñanza, la creación de elementos de aprendizaje que ayuden a aplicar los distintos elementos teóricos, la generación de herramientas para construir modelos GPSS, y la construcción de herramientas para comprender el motor de simulación por dentro.
En esta tesis se introduce una herramienta de software que permite construir modelos GPSS de manera interactiva, cuyo diseño fue pensado para integrar los elementos teóricos del curso con los objetos y entidades de GPSS. Esta herramienta también permite ejecutar estos modelos y analizar con alto nivel de detalle su evolución a través del tiempo de simulación, lo que permite a los estudiantes comprender cómo funciona el motor de simulación y cómo interactúan las distintas entidades entre sí. Se incluye también una propuesta de enseñanza basada en una fuerte participación de los estudiantes, que, por medio de esta nueva herramienta, les permite incorporar los conceptos más fácilmente. Esta propuesta de enseñanza fue puesta a prueba con alumnos del área de sistemas, quienes tomaron un curso que contiene los m
Ver registro completo en: http://sedici.unlp.edu.ar/handle/10915/29753
El uso intensivo de las TIC en los procesos educativos de las Instituciones de Educación Superior de América y latina y el mundo, ha generado cambios en la forma de producir los contenidos destinados específicamente para la virtualidad, impulsando el uso de nuevas herramientas y metodologías que apunten a optimizar los procesos de producción y con ello lograr aportes sustanciales a la forma en la que los usuarios interactúan con los recursos educativos.
La propuesta de la Dirección de Educación Virtual de la Universidad Tecnológica de Bolívar en Cartagena de Indias, Colombia da cuenta de un proceso estructurado que utiliza programas basados en software libre buscando no sólo la estandarización, sino una revolución en la forma de crear contenidos, estructurarlos y gestionarlos.
Este documento busca introducir al lector en la experiencia de la Dirección de Educación Virtual de la UTB al mostrar los antecedentes de trabajo, las exploraciones y finalmente los resultados a los que se ha llegado desde sus inicios en el año 2001.
Este trabajo se focaliza en medir el grado de adopción de las TIC en las empresas de servicios de Colombia, a partir de índices compuestos y luego investigar cuáles son los factores determinantes de la difusión de las TIC en las empresas de servicios, así como el impacto de las TIC (tanto en términos de inversión como de uso) en la productividad laboral.
Similar a Manual de prácticas y antología para POO (20)
Los desafíos de calidad de software que nos trae la IA y los LLMsFederico Toledo
En esta charla, nos sumergiremos en los desafíos emergentes que la inteligencia artificial (IA) y los Large Language Models (LLMs) traen al mundo de la calidad del software y el testing. Exploraremos cómo la integración, uso o diseño de modelos de IA plantean nuevos retos, incluyendo la calidad de datos y detección de sesgos, sumando la complejidad de probar algo no determinístico. Revisaremos algunas propuestas que se están llevando adelante para ajustar nuestras tareas de testing al desarrollo de este tipo de sistemas, incluyendo enfoques de pruebas automatizadas y observabilidad.
Si bien los hospitales conjuntan a profesionales de salud que atienden a la población, existe un equipo de organización, coordinación y administración que permite que los cuidados clínicos se otorguen de manera constante y sin obstáculos.
Mario García Baltazar, director del área de Tecnología (TI) del Hospital Victoria La Salle, relató la manera en la que el departamento que él lidera, apoyado en Cirrus y Estela, brinda servicio a los clientes internos de la institución e impulsa una experiencia positiva en el paciente.
Conoce el Hospital Victoria La Salle
Ubicado en Ciudad Victoria, Tamaulipas, México
Inició operaciones en el 2016
Forma parte del Consorcio Mexicanos de Hospitales
Hospital de segundo nivel
21 habitaciones para estancia
31 camas censables
13 camillas
2 quirófanos
+174 integrantes en su plantilla
+120 equipos médicos de alta tecnología
+900 pacientes atendidos
Servicios de +20 especialidades
Módulos utilizados de Cirrus
HIS
EHR
ERP
Estela - Business Intelligence
Escaneo y eliminación de malware en el equiponicromante2000
El malware tiene muchas caras, y es que los programas maliciosos se reproducen en los ordenadores de diferentes formas. Ya se trate de virus, de programas espía o de troyanos, la presencia de software malicioso en los sistemas informáticos siempre debería evitarse. Aquí te muestro como trabaja un anti malware a la hora de analizar tu equipo
1. Tecnológico Nacional de México
Instituto Tecnológico Superior de Guasave
Ingeniería en Sistemas Computacionales
Programación Orientada a Objetos
Manual de Prácticas
y Antología
Autor
M.S.I. José Antonio Sandoval Acosta
Guasave, Sin. Junio de 2023
2. 2
Tecnológico Nacional de México
Instituto Tecnológico Superior de Guasave
Directorio
Dr. José Lorenzo Meza García
Director General del TecNM Campus ITS de Guasave
Lic. Jaime Cabanillas Torres
Subdirector Académico y de Investigación e Innovación
Lic. Jesús Lizbette Félix Acosta
Subdirectora de Extensión y Vinculación
MAP. Celia Yudith Bea Berrelleza
Subdirectora de Planeación y Desarrollo
Lic. Martha Mayumy Ascárrega Armenta
Subdirectora de Servicios Administrativos
Ing. Manuel Alfredo Flores Rosales
Jefe de División de Ciencias Computacionales
Ing. Graciela Lugo Rubio
Presidenta de Academia de Ingeniería en Sistemas Computacionales
Mtro. José Antonio Sandoval Acosta
Autor
3. 3
Tabla de Contenido
Introducción............................................................................................................. 8
Unidad 1: Introducción al Paradigma de la Programación Orientada a Objetos...... 9
Competencia de la unidad....................................................................................... 9
Introducción a la unidad .......................................................................................... 9
¿Qué significa paradigma? ..................................................................................... 9
Las ventajas de la POO ........................................................................................ 10
Los Objetos ........................................................................................................... 11
Las Clases............................................................................................................. 11
Ejercicio: Clases.................................................................................................... 12
Encapsulamiento................................................................................................... 12
Ejercicio: Encapsulamiento ................................................................................... 13
Herencia................................................................................................................ 13
Ejercicio: Herencia ................................................................................................ 13
Polimorfismo.......................................................................................................... 14
Ejercicio: Polimorfismo .......................................................................................... 14
Abstracción............................................................................................................ 14
Ejercicio: Abstracción ............................................................................................ 15
Práctica ................................................................................................................. 16
Modelado de Clases y Objetos con UML .............................................................. 17
Diagrama de Clases.............................................................................................. 17
Práctica ................................................................................................................. 20
Asociación (Conexión entre clases) ...................................................................... 21
Multiplicidad........................................................................................................... 21
Rangos.................................................................................................................. 21
Agregaciones (Posee/contiene) ............................................................................ 22
Ejercicio: Agregaciones (Posee/contiene) ............................................................. 22
Composición.......................................................................................................... 22
4. 4
Dependencia (relación de uso).............................................................................. 22
Representación UML............................................................................................. 23
Ejercicio: Dependencia (relación de uso) .............................................................. 23
Generalizaciones (Herencia/Especificación) ......................................................... 23
Ejercicio: Generalizaciones ................................................................................... 24
Práctica ................................................................................................................. 25
Unidad 2: Clases y Objetos................................................................................... 26
Competencia de la unidad..................................................................................... 26
Lenguaje de programación a utilizar ..................................................................... 26
C # (Visual Studio para trabajar en modo consola) ............................................... 26
Identificadores en C# ............................................................................................ 26
Tipos de Datos en C#............................................................................................ 26
Declaración de Variables....................................................................................... 27
Sentencias using................................................................................................... 27
Pedir Datos (captura en proyectos de consola)..................................................... 28
Cálculos y Asignaciones........................................................................................ 28
Operadores Aritméticos......................................................................................... 29
Jerarquías ............................................................................................................. 29
Operadores de asignación adicionales ................................................................. 29
Clases y objetos.................................................................................................... 30
Cómo declarar una clase ...................................................................................... 30
Modificadores de acceso....................................................................................... 31
Atributos o campos................................................................................................ 31
Creación de objetos .............................................................................................. 32
Instanciación ......................................................................................................... 32
Accediendo a los miembros de los objetos ........................................................... 32
Asignación............................................................................................................. 32
Métodos ................................................................................................................ 32
La referencia this................................................................................................... 33
5. 5
Sobrecarga............................................................................................................ 34
Método constructor................................................................................................ 35
¿Qué es un constructor?....................................................................................... 35
Práctica ................................................................................................................. 37
Práctica ................................................................................................................. 38
Práctica ................................................................................................................. 39
Operadores en la POO.......................................................................................... 40
Operadores Relacionales...................................................................................... 40
Operadores Lógicos.............................................................................................. 40
Decisiones (if)........................................................................................................ 40
Selección Múltiple ................................................................................................. 41
Ciclo for() { } .......................................................................................................... 41
Ciclo while { }......................................................................................................... 42
Ciclo do { } while( ) ................................................................................................ 42
Práctica ................................................................................................................. 43
Práctica ................................................................................................................. 44
Sobrecarga de métodos ........................................................................................ 45
Ejercicio de sobrecarga......................................................................................... 45
Práctica ................................................................................................................. 46
Unidad 3: Herencia................................................................................................ 47
Competencia de la unidad..................................................................................... 47
Introducción........................................................................................................... 47
Redefinición de métodos....................................................................................... 47
Principio de subtipos ............................................................................................. 49
Herencia de variables y métodos .......................................................................... 50
Herencia en C# ..................................................................................................... 51
Ejercicio de herencia ............................................................................................. 51
Práctica ................................................................................................................. 53
Unidad 4: Polimorfismo ......................................................................................... 54
6. 6
Competencia de la unidad..................................................................................... 54
Introducción........................................................................................................... 54
Polimorfismo.......................................................................................................... 54
Ejercicio de polimorfismo ...................................................................................... 56
Mapa conceptual de Polimorfismo ........................................................................ 56
Diferencia entre Sobrecarga y Polimorfismo ......................................................... 58
Ejercicio................................................................................................................. 58
Práctica ................................................................................................................. 59
Unidad 5: Interrupciones ....................................................................................... 60
Competencia de la unidad..................................................................................... 60
¿Qué son las Excepciones?.................................................................................. 60
El bloque catch...................................................................................................... 61
El bloque finally ..................................................................................................... 61
Tratamiento de las excepciones............................................................................ 62
Tipos de excepciones más comunes..................................................................... 63
Lanzamiento de una excepción throw()................................................................. 63
Práctica ................................................................................................................. 64
Unidad 6: Archivos ................................................................................................ 65
Competencia de la unidad:.................................................................................... 65
¿Cómo surge la necesidad de utilizar archivos?................................................... 65
Definiciones básicas.............................................................................................. 66
Datos..................................................................................................................... 66
Registro................................................................................................................. 66
Archivo .................................................................................................................. 66
Clasificación de archivos por tipo de contenido..................................................... 66
Archivos de texto................................................................................................... 67
Archivos binarios................................................................................................... 67
Representación Lógica de un Archivo Binario Organizado en Renglones y Columnas
.............................................................................................................................. 68
7. 7
Manejo de Archivos de Texto................................................................................. 68
Declaración del alias del archivo........................................................................... 68
Nombre del archivo que guardará la información en texto plano .......................... 69
Streams................................................................................................................. 69
BufferedStream ..................................................................................................... 70
Constructores de StreamReader........................................................................... 71
Lectura con StreamReader ................................................................................... 71
ReadLine()............................................................................................................. 71
ReadToEnd() ......................................................................................................... 72
Read() ................................................................................................................... 72
Escritura: StreamWriter ......................................................................................... 72
Constructores de StreamWriter............................................................................. 73
Escritura con StreamWriter ................................................................................... 73
WriteLine()............................................................................................................. 73
Write().................................................................................................................... 74
Práctica ................................................................................................................. 75
Archivos Binarios................................................................................................... 76
BinaryWriter........................................................................................................... 76
Binaryreader.......................................................................................................... 77
Acceso Aleatorio.................................................................................................... 78
Práctica ................................................................................................................. 81
28. 28
Parámetros de sustitución
Concatenación
El resultado se almacena
en esta variable Conversión de String a Entero
TAMBIEN puede hacerse así:
Pedir un dato String
Asignación
Cálculos