Mostrando entradas con la etiqueta Haskell. Mostrar todas las entradas
Mostrando entradas con la etiqueta Haskell. Mostrar todas las entradas

jueves, 22 de octubre de 2015

Inter: Por qué ciertos lenguajes

Explico sucintamente aquí por qué trabajo con algunos lenguajes en particular:

a) Prolog. Las bases lógicas de este lenguaje, su delicado equilibrio entre teoría y práctica, y sus 
aplicaciones a la inteligencia artificial, a deducciones y reescritura de términos hacen para mí
de Prolog una herramienta ideal en la investigación de la inteligencia humana y sus repercusiones 
en el razonamiento.

b) Haskell. Haskell tiene entre sus virtudes una definición de su semántica completa en un 100%,
con un concepto anexo de mónadas para el tratamiento de características "extra-formales"; la 
sistemática utilización de funciones, dominios y codominios (tipos), y su cercanía con el área de 
matemática de Teoría de categorías hacen de este lenguaje un auténtico paraiso computacional 
con muchas posibilidades aún por explorar.

c) Erlang. Erlang es un lenguaje nacido para tratar con sistemas distribuidos. Erlang, como Prolog
y Haskell, es también de propósito general, con ello implicando que, al dominar este lenguaje, 
seremos capaces de crear nuestros propios programas para resolver problemas específicos, sobre
todo aquellos relacionados con sistemas distribuidos y cómputo distribuido, dos temas fascinantes
de actualidad. 

d) Scheme. Scheme es la versión previa a Haskell, ambos fundamentos teóricamente en el Cálculo 
Lambda. Es una elección natural para los perversos quienes gustamos de pensarnos entre paréntesis.

e) Python. Python es la única elección imperativa que tengo. Tiene lo suficiente de clases para 
propósitos de tipos (con herencia simple, sobrecarga de operadores), contiene una buena cantidad
de construcciones de alto nivel (listas compactas) y de "funciones" de alto orden. Es una elección 
directa para propósitos de enseñanza y transición entre otros lenguajes imperativos y nuevas 
tendencias. 

Ojo: Hay <<miles>> de lenguajes de programación (ok, pongamos, cientos): los lenguajes previos son 
representativos de la lógica, las funciones, y el punto de vista pragmático de solventar con prontitud y
eficiencia (además de corrección) la resolución de problemas <<reales>>.

lunes, 19 de octubre de 2015

Invitado: Unas esferitas en Haskell


---El siguiente programa muestra algunas posibilidades de trabajo gráfico en 3D
---con Haskell; estas posibilidades son dignas de explorar en la creación de mundos
---virtuales, simulación, graficación de datos, y juegos.
---He puesto un vida de otro programa que seguiría un desarrollo más o menos natural
---al aquí presentado, brindando más experiencia tridimensional e interactiva en
 -------https://youtu.be/Ab7eQdMHF-Q
{-
   Light.hs (adapted from light.c which is (c) Silicon Graphics, Inc.)
   Copyright (c) Sven Panne 2002-2005 <sven.panne@aedion.de>
   This file is part of HOpenGL and distributed under a BSD-style license
   See the file libraries/GLUT/LICENSE

   This program demonstrates the use of the OpenGL lighting model. A sphere
   is drawn using a grey material characteristic. A single light source
   illuminates the object.
-}


---Compilado con
---> ghc -package GLUT Light.hs -o light
---en Fedora, con Haskell tomado de www.haskell.org


import System.Exit ( exitWith, ExitCode(ExitSuccess) )
import Graphics.UI.GLUT

windowWidth=500
windowHeight=500
blackBackground=Color4 0 0 0 0
whiteColor=Color4 1 1 1 1
degreeShininess=50

myInit :: IO ()
myInit = do
   clearColor $= blackBackground
   shadeModel $= Smooth

   materialSpecular Front $= whiteColor
   materialShininess Front $= degreeShininess
   position (Light 0) $= Vertex4 1 1 1 0
   position (Light 1) $= Vertex4 1 1 (-1) 0
   lighting $= Enabled
   light (Light 0) $= Enabled
   light (Light 1) $= Enabled
   depthFunc $= Just Less

-- Sphere(radius,subLat,subLon)

translatef = translate :: Vector3 GLfloat -> IO ()
rotatef = rotate :: GLfloat -> Vector3 GLfloat -> IO ()
rectf = rect :: Vertex2 GLfloat -> Vertex2 GLfloat -> IO ()
normal3f = normal :: Normal3 GLfloat -> IO ()
color3f = color :: Color3 GLfloat -> IO ()
     
display :: DisplayCallback
display = do
   clear [ ColorBuffer, DepthBuffer ]
   rotatef 30 (Vector3 1 0 0)
   normal3f (Normal3 0 0 1)
   color3f (Color3 1 0.1 1)
 --  renderObject (
   translatef (Vector3 0 0 (-2.0))
   rectf (Vertex2 (-20) (-20)) (Vertex2 20 20)
   translatef (Vector3 0 0 (2.0))
   translatef (Vector3 0 0 (1.0))
   renderObject Solid (Sphere' 0.3 20 16)
   translatef (Vector3 0.5 0 0)
   renderObject Solid (Sphere' 0.3 20 16)
   translatef (Vector3 0 0.5 0)
   renderObject Solid (Sphere' 0.3 20 16)
   translatef (Vector3 0.5 0.5 0)
   renderObject Solid (Cube 0.6)

   flush

reshape :: ReshapeCallback
reshape size@(Size w h) = do
   viewport $= (Position 0 0, size)
   matrixMode $= Projection
   loadIdentity
   let wf = fromIntegral w
       hf = fromIntegral h
   if w <= h
      then ortho (-1.5) 1.5 (-1.5 * hf/wf) (1.5 * hf/wf) (-10) 10
      else ortho (-1.5 * wf/hf) (1.5 * wf/hf) (-1.5) 1.5 (-10) 10
   matrixMode $= Modelview 0
   loadIdentity

keyboard :: KeyboardMouseCallback
keyboard (Char '\27') Down _ _ = exitWith ExitSuccess
keyboard _            _    _ _ = return ()

main :: IO ()
main = do
   (progName, _args) <- getArgsAndInitialize
   initialDisplayMode $= [ SingleBuffered, RGBMode, WithDepthBuffer ]
   initialWindowSize $= Size windowWidth windowHeight
   initialWindowPosition $= Position 100 100
   createWindow progName
   myInit
   displayCallback $= display
   reshapeCallback $= Just reshape
   keyboardMouseCallback $= Just keyboard
   mainLoop