Profile

Cover photo
Javier Neira Sanchez
Works at ECNA
Attends UNED
Lives in Amurrio
82 followers|4,211 views
AboutPostsPhotosVideos

Stream

Javier Neira Sanchez

Shared publicly  - 
 
 
Regarding 'Adverbs'

In word-based functional concatenative languages, it isn't difficult to express that a word is mapped over a sequence. Some expression of the form:
 
        [ foo ] each

should be sufficient. Unfortunately, use of brackets for quotation becomes surprisingly noisy and difficult to read in practice, i.e. once we have sentences of more than a few words.

J and K languages have an interesting concept of 'adverbs', which modify how a word is applied without explicitly reifying the word. Applied to languages like Factor or AO, adverbs could greatly reduce noise and improve parsimony. I propose we steal this nice feature of J and K and adapt it to concatenative languages.

To realize adverbs in a concatenative, word-based PL requires representing adverbs within the structure of the word, i.e. such that we can modify the word without quoting it. I propose use of a suffix. We might imagine that:

        foo⋆

should have the same behavior as `[ foo ] each`, but without any requirement to define `foo⋆` explicitly. This technique should be composable and concatenative, such that `foo⋆⋆` has the behavior of `[ [ foo ] each ] each` - thereby operating on each element of a matrix. 

(Sadly, even in 2014 not all readers will correctly render unicode. If you're not seeing stars (U+22C6), this post might not make full sense.) 

We could further formalize this behavior, and support user-defined adverbs, while sticking aggressively to the concatenative philosophy. For example, we might systematically rewrite `foo⋆⋆` as:

        [ foo ] \⋆ \⋆ inline

Here, `inline` is a trivial combinator such that `∀foo . [ foo ] inline = foo`. Though... this particular semantics is less-than-ideal because it allows adverb `\⋆` access to the full stack. The type for an adverb should be  `(x→y)→(x'→y')` - i.e. a context-free function from verb to verb. So the actual rewrite might be a little bit more involved.

At least one important requirement remains to be addressed:  I need a systematic way to parse `foo⋆⋆` into a word with two adverbs! Why not `[ foo ] \⋆⋆ inline` or `[ f ] \o \o \⋆ \⋆ inline`? 

The obvious answer, I think, is to reserve a few characters and introduce some disambiguating syntactic structure for parsing words. For example, I could use a backslash like `foo\⋆\⋆`. But, IMO, that is aesthetically unpleasing and risks aggregating the same syntactic noise I'm hoping to avoid in the first place. I could use an invisible character (e.g. U+2060) but that would only succeed in confusing readers of code.

Can we do better?

In a few conversations regarding adverbs, my strong impression was that we don't need many of them - that just a few can go a very long way. If this is true, then perhaps we could restrict to one character per adverb. That restriction appeals both to parsimony and my aesthetic sense. So we could have `foo\⋆⋆` - not too bad.

Perhaps, then, we could make adverbs separable from their use, i.e. such that `\⋆⋆` can be understood separately from its use on 'foo'. This will make it easier to refactor code using adverbs. Also, rewriting then becomes much more incremental. Perhaps:

        foo\⋆⋆ = [ foo ] \⋆⋆ inline = [ foo ] \⋆ \⋆ inline

Potential roles for adverbs include:

* collection-oriented operations (map/each, fold)
* minor data shuffling - e.g. flipped arguments
* quotation of a single word
* partial application and currying
* deep application - dip, zippers
* exponentiation, bi, tri, etc.
1
Add a comment...

Javier Neira Sanchez

Shared publicly  - 
 
 
En el curso del estudio de algoritmos (en la uned y coursera) escribi alguna versiones de varios algoritmos clasicos: prim, kruskal, djikstra. Comentarios bienvenidos
 ·  Translate
1
Add a comment...

Javier Neira Sanchez

Shared publicly  - 
 
 
"Una introducción agradable a Haskell, versión 98" es una traducción de "A gentle introduction to Haskell, version 98" realizada por José Gallardo, Paco Gutiérrez y Blas Ruiz.
1
Add a comment...
 
Venga quien se anima a hacer el primer (?) tutorial sobre monadas en castellano. Voto por hacer la tradicional metafora usando un toro
 ·  Translate
1
Add a comment...
 
Hace poco @_josejuan_ publico un pequeño tutorial introductorio a yesod en castellano.
 ·  Translate
1
José A. Alonso's profile photoJavier Neira Sanchez's profile photo
2 comments
 
La página se creó hace tiempo (en octubre del 2006), pero se actualiza poco (desde el 2010 sólo ha tenido 3 actualizaciones).

He añadido tutorial de Yesod de @josejuan http://tutorial-yesod-haskell.computer-mind.com/static/tutorial/yesod_tutorial.html
 ·  Translate
Add a comment...
Have him in circles
82 people
Channing Walton's profile photo
Hubert Klein Ikkink's profile photo
Edu Rodríguez's profile photo
Ixone durana's profile photo
Alberto Peña Abril's profile photo

Javier Neira Sanchez

Shared publicly  - 
 
 
Haskell y sus mónadas, con un breve trasfondo matemático que nunca deja de ser necesario.
 ·  Translate
1
Add a comment...
 
En el curso del estudio de algoritmos (en la uned y coursera) escribi alguna versiones de varios algoritmos clasicos: prim, kruskal, djikstra. Comentarios bienvenidos
 ·  Translate
1
1
Add a comment...

Javier Neira Sanchez

Shared publicly  - 
 
 
Necesito rantear un rato. Uhm.

En mi asignatura Sistemas Distribuidos nos mandan una práctica muy simplona de hacer tres programas, uno para clientes, otro para distribuidores, y otro «regulador» al que se conectan los otros dos para hacerse ofertas y demandas. (Por supuesto, ellos no dicen «programa» sino «entidad» y «actor».) Hay que usar una cosa de Java que se llama RMI (ya tiene delito esto, pero en fin) para que se comuniquen entre sí.

Bien. Aparte de tener los programas funcionando, te piden una memoria en PDF con diagramas de clase y pantallazos. También te dicen qué nombre tienen que llevar las clases (dan por hecho que vas a usar clases a tutiplén, Dios te libre de pensar en alternativas más simples para algo tan tonto), que si hagas los .jar así y asá y que uses List y HashMap que molan un huevo.

Un diagrama de clases. Para un servicio que en un lenguaje decente llevaría menos de cien líneas de código en total. Una memoria de menos de cincuenta páginas, dice. ¿De verdad eso es lo más importante? ¿De verdad eso es el corazón de lo que hacemos? ¿Pintar un diagrama de clases? Para qué, ¿para que nadie tenga que leer nuestro código?

Tenemos unas máquinas increíblemente mágicas debajo de nuestros dedos y sólo nos educan para parir software como quien rellena facturas. Se han inventado cientos de lenguajes, cada uno con sus peculiaridades, cada uno con un modo distinto, fresco, innovador de enfocar cada elemento programable, una semántica especializada en expresar ciertos patrones; podemos combinar todo esto como mejor se nos ocurra e incluso inventar nuevas formas de entender y solucionar cada problema, como quien compone una canción. Deberían enseñarnos a estar ávidos por leer el código ajeno en busca de algo de esa belleza de expresión, y a escribir nuestro código intentando crearla, usando tu ingenio y tu intuición para lograr lo que piensas que es un diseño elegante y efectivo.

Pero no. Usa Java, usa Eclipse, usa putas clases que sirven para todo y lo expresan todo bien, hazlo como te salga del pito pero al final hazme una memoria con dibujitos de entidades actoriles tirándose flechas entre ellas, porque es en eso en lo que consiste el desarrollo de software.

Lo peor, lo trágico es el terrible porcentaje de gente que sale la carrera sin sentir ni mínimante lo que hay más allá de toda esa burocracia cárnica, sin saber en qué consiste lo que han estudiado. Y todo por la desidia, la falta de pasión la despreocupación por lo que realmente están enseñando de los profesores. En fin.
 ·  Translate
1
Add a comment...

Javier Neira Sanchez

Shared publicly  - 
 
Intento que el tratamiento de las excepciones sea lo menos invasivo sintactica y semanticamente:
* Usar RuntimeExceptions donde sea posible "sin que duela": Hay un amplia variedad que viene de serie (IllegalArgument,IllegalState) y si el mensaje de texto y la posible excepcion causante son suficientes para tratar el error es mi primera opcion.
* Puedes crear tus propias excepciones que desciendan de ella (con sus datos especificos) y hacer catch como las otras pero no es obligatorio. No hay que declararlas con throws en el metodo que la lanza ni obligas al que llama a recogerlas. Es una dependencia mas que creas entre los dos metodos y en la mayoria de los casos la restriccion que crea no es util (o para mi no lo es). El hecho de modificar el throws hace que tengas que modificar todo el codigo que lo llama (a veces en toda la cadena de llamadas) y a mi me ha dado mas quebraderos de cabeza que ventajas.
* Cada uno pone el limite en un sitio diferente pero prefiero tratar los errores "logicos" de la aplicacion o que estan previstos que puedan pasar sin usar las excepciones en la medida de lo posible. Prefiero que la devolucion normal del metodo refleje la posibilidad de esos errores previstos y no usar la excepcion como un retorno de datos alternativo.
2
1
Javier Neira Sanchez's profile photoMauricio Scheffer's profile photoJosejuan Pi's profile photoEdu Rodríguez's profile photo
4 comments
 
Las excepciones son un recurso soportado en muchas (sino todas) capas/componentes de una aplicación empresarial. Desde un punto de vista productivo, las excepciones te permiten compartir las reglas de negocio entre capas/componentes sin tener que realizar NINGUN esfuerzo a la hora de programar (enlazar esas capas/componentes). Obviamente es mi opinión, pero estoy fuertemente convencido de que la repulsa a usar excepciones proviene de una exacerbada aplicación de técnicas como TDD y un mal uso de las excepciones. Pretender controlar o evitar la propagación de las excepciones es como reinventar la rueda. ¿Para que narices quiero yo controlar una excepción que se eleva desde la base de datos (por ejemplo) si dicha excepción ESTÁ BIEN ELEVADA?, yo dejaré que la excepción fluya tranquilamente desde la base de datos al mapeador, de éste a la lógica empresarial, de ésta a la biblioteca de mi negocio, de ésta al servidor de aplicaciones, de éste al protocolo de transmisión (eg. ajax) y sólo al final y de modo general, mostraré dicho error al usuario (con un código que capturará todas las excepciones símplemente para aplicarles un formato). Cuando mi biblioteca la use en un servicio de sistema, esas mismas excepciones se registrarán en los log y/o serán enviadas como notificaciones a quienes correspondan. Todo ésto, sin escribir NADA que controle dichas excepciones.

El uso de tipos algebráicos (Mauricio) sólo estarán visibles en su contexto (eg. Maybe en Haskell) y efectivamente, si alquien está lanzando excepciones entre sus propias funciones (métodos, ...) probablemente esté haciendo algo mal. Pero por eso mismo, porque NO TIENE NADA QUE VER, debe dejarse claro que se trata de un (probablemente) MAL USO de las excepciones.

Las excepciones son UNA FANTÁSTICA HERRAMIENTA que simplifica tremendamente la interconexión de sistemas por un lado, y permite dejar clara y patente (con su pertinente traza) las meteduras de pata de un programador.

En Java, lo que ya no me gusta tanto, es tener que marcar en los métodos las excepciones que se permite que se eleven, pero como yo raramente programo en Java, no me importa mucho XD XD XD
 ·  Translate
Add a comment...
People
Have him in circles
82 people
Channing Walton's profile photo
Hubert Klein Ikkink's profile photo
Edu Rodríguez's profile photo
Ixone durana's profile photo
Alberto Peña Abril's profile photo
Work
Occupation
Developer
Employment
  • ECNA
    Developer, present
  • Steria
Places
Map of the places this user has livedMap of the places this user has livedMap of the places this user has lived
Currently
Amurrio
Previously
Zaragoza
Contact Information
Work
Email
Story
Introduction
Historician transmuted in j2ee code monkey and clojure/haskell novice
Education
  • UNED
    present
  • UNIZAR
Basic Information
Gender
Male