tag:blogger.com,1999:blog-10815862957006845332024-02-20T04:38:50.483-03:00LayerD´s blogBlog about LayerD technology. Project news, articles, samples, links.Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.comBlogger26125tag:blogger.com,1999:blog-1081586295700684533.post-85145108462857619922012-07-23T21:03:00.001-03:002012-07-23T21:03:36.193-03:00LayerD is aliveYeap! this project is still alive!!
<a href="http://code.google.com/p/layerd/wiki/Home">Visit us in Google Code</a>
Now with support for C++ and Javascript code generators :)Alexis Ferreyrahttp://www.blogger.com/profile/14282185824248514317noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-73868175550463589072009-05-25T20:08:00.002-03:002009-05-25T20:15:29.295-03:00LayerD SDK 0.5.3<span xmlns=""><p>I've updated the LayerD SDK with a new release that includes several bug fixes. It doesn't include new functionality from 0.5.2. It fixes an annoying bug that occurred the first time that you use a new assembly for .NET platform :-) .<br /></p><p>Download the SDK on SourceForge: <a href="http://sourceforge.net/projects/layerd">http://sourceforge.net/projects/layerd</a><br /> </p></span><span class="Apple-style-span" style="border-collapse: separate; color: rgb(0, 0, 0); font-family: 'times new roman'; font-size: 16px; font-style: normal; font-variant: normal; font-weight: normal; letter-spacing: normal; line-height: normal; orphans: 2; text-indent: 0px; text-transform: none; white-space: normal; widows: 2; word-spacing: 0px;"><h1>LayerD SDK Release Alpha 0.5.3</h1><p>This SDK version Alpha 0.5.3 includes the following components:</p><ul><li>Meta D++ compiler</li><li>Zoe compiler</li><li>Zoe Code Generator for .NET</li><li>Zoe Code Generator for Java</li><li>Interactive Zoe Code Generator for Meta D++</li><li>Sample extensions to Zoe compiler</li><li>Zoe CodeDOM and Compiler documentation generated from code (<span class="Apple-converted-space"> </span><a href="docs%5CCodeDOM-Reference%5Cindex.html">\doc\CodeDOM-Reference\index.html</a><span class="Apple-converted-space"> </span>)</li><li>Meta D++ programming guide for .NET programmers, Spanish only (<span class="Apple-converted-space"> </span><a href="docs%5CInstructivo%20de%20LayerD%20para%20dotNET.pdf">\docs\Instructivo de LayerD para dotNET.pdf</a><span class="Apple-converted-space"> </span>)</li><li>Meta D++ Programmers Guide, Spanish only (Manual de Usuario Meta D++), (<span class="Apple-converted-space"> </span><a href="docs%5CManual%20de%20Meta%20D++%20v1.0.0.pdf">\docs\Manual de Meta D++ v1.0.0.pdf</a><span class="Apple-converted-space"> </span>)</li><li>Sample programs (\Samples)</li></ul><h2>Quick start</h2><p>To make programs on LayerD framework you must make the programs on one high level language (currently Meta D++, also there is a Java clon that is distributed separately). After that, you must compile Meta D++ source code using metadppc.exe compiler and the generated .zoe files with zoec.exe compiler. Check the instructions on Meta D++ Programmers Guide.</p><p>It’s recommended to read the Meta D++ programming guide for .NET programmers even if you don’t program for that platform because of generic concepts explained in this document.</p><p>There isn’t an IDE currently available. I use Notepad++ editor or Visual Studio and have custom macros that call compilers. You can use any text editor.</p><p><strong>Note:</strong><span class="Apple-converted-space"> </span>There is plug-in for Visual Studio that implements a kind of “Intellisense”; it’s only a concept and don’t work on programs that have more than one file but it can be useful (on files with less than 1500 lines of code :-P ).</p><p>More information on:<span class="Apple-converted-space"> </span><a href="http://layerd.net/">http://layerd.net</a>,<span class="Apple-converted-space"> </span><a href="http://layerd.blogspot.com/">http://layerd.blogspot.com</a>,<span class="Apple-converted-space"> </span><a href="http://sourceforge.net/projects/layerd">http://sourceforge.net/projects/layerd</a>.</p><p>Please don’t hesitate to contact me at<span class="Apple-converted-space"> </span><a href="mailto:alexis.ferreyra@yahoo.com">alexis.ferreyra@yahoo.com</a><span class="Apple-converted-space"> </span>for information or if you want to contribute with the project.</p><h2>Compiler Usage and Hello World programs</h2><p>Compiler Usage and hello world programs:<span class="Apple-converted-space"> </span><a href="http://layerd.wiki.sourceforge.net/compiler_usage">http://layerd.wiki.sourceforge.net/compiler_usage</a></p><h2>Debugging</h2><p>Programs can be debugged using standard infrastructure of the target platform. For example, if you program for .NET you can use Visual Studio or SharpDevelop for debugging. If you develop for Java take into account that Zoe Code Generator for Java is Alpha version and don´t generate equivalence between Meta D++ source code and generated Java code, so it will be a bit more challenging but you can use any Java IDE to debug generated code, frequently visit LayerD’s website because this module will be updated frequently. /p></p><p>To debug classfactorys (compile time functionality) you can use –wfd flag on zoec.exe compiler the compiler will wait until a compiler attaches to the compiler process before continue. So you can run the compilation with –wfd flag and attach to zoec.exe process from a debugger like Visual Studio (first set breakpoints on compile time source code).</p><h2>Languages features implemented on this SDK</h2><p>LayerD is a large, ambitious and little complex project so not all desired features of Meta D++, Zoe, and Zoe Code Generators are implemented. Currently these are the features included until now:</p><ul><li>Main features of Zoe and Meta D++ languages to support standard object oriented programming like classes, interfaces, single inheritance, enumerations and statements.</li><li>Compilation of Classfactorys, standard and interactive.</li><li>Multiple compile times on Zoe compiler.</li><li>Interactive compilation for Meta D++ language.</li><li>Generation of .NET assemblies for desktop and mobile, .exe and .dll.</li><li>Generation of .class files for Java (using javac compiler)</li><li>Automated import of types for .NET platform but not including generic types, nulleables and attributes.</li><li>Automated import of types for Java platform but not including generic types or annotations.</li></ul><h2>Changes from 0.5.2 version</h2><ul><li>Know bug when first compiling a program for .NET fixed.</li><li>Bugs while merging nodes at compile time fixed.</li><li>Bugs about expressions not being captured for compile time execution fixed.</li><li>Several bugs on Java importer module fixed.</li><li>Several bugs on .NET and Java code generator fixed.</li></ul><h2>Documentation</h2><ul><li>Zoe CodeDOM and Compiler documentation generated from code (<span class="Apple-converted-space"> </span><a href="docs%5CCodeDOM-Reference%5Cindex.html">\doc\CodeDOM-Reference\index.html</a><span class="Apple-converted-space"> </span>)</li><li>Meta D++ programming guide for .NET programmers, Spanish only (<span class="Apple-converted-space"> </span><a href="docs%5CInstructivo%20de%20LayerD%20para%20dotNET.pdf">\docs\Instructivo de LayerD para dotNET.pdf</a><span class="Apple-converted-space"> </span>)</li><li>Meta D++ Programmers Guide, Spanish only (Manual de Usuario Meta D++), (<span class="Apple-converted-space"> </span><a href="docs%5CManual%20de%20Meta%20D++%20v1.0.0.pdf">\docs\Manual de Meta D++ v1.0.0.pdf</a><span class="Apple-converted-space"> </span>)</li><li>LayerD Wiki (English)<span class="Apple-converted-space"> </span><a href="http://layerd.wiki.sourceforge.net/">http://layerd.wiki.sourceforge.net/</a></li><li>LayerD Blog<span class="Apple-converted-space"> </span><a href="http://layerd.blogspot.com/">http://layerd.blogspot.com<br /></a></li></ul><h2>LayerD SDK FAQ</h2><h4>Why is this SDK in mixed English / Spanish ?</h4><p>Because I don't have time to maintain both English and Spanish SDK. So, I'm translating all to English. If you want to help me that will be great!!</p><h4>There is a distribution for Linux ?</h4><p>No, there isn't. It's perfectly possible to compile all modules in Linux but I don't have time to do that and I use Windows more than Linux. May be you can help me with this task.</p><h4>Can be used to develop commercial applications ?</h4><p>Yes, In fact it was used for at least two pretty big commercial projects (both on .NET). Please let me know if you use LayerD on a commercial project ! You don't have to pay me for that, this is a free and open source project. If you make money consider a donation :-)</p><strong>Thanks for downloading LayerD SDK,<span class="Apple-converted-space"> </span><br />Be happy doing compile time programming :-)<span class="Apple-converted-space"> </span><br /><br />Distribution date: May 25, 2009</strong></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com2tag:blogger.com,1999:blog-1081586295700684533.post-39900517026979145882009-05-24T21:04:00.001-03:002009-05-24T21:04:46.654-03:00How to use LayerD compilers<span xmlns=''><p><strong>Meta D++ compilation<br /></strong></p><p>To compile a Meta D++ program into a Zoe program use the "metadppc.exe" compiler:<br /></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>C:\LayerD\bin\metadppc.exe helloworld.dpp<br /></span></p><p>That will generate a file with the same name but with .zoe extension.<br /></p><p>To compile a program composed of more than one file call the compiler for each file:<br /></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>C:\LayerD\bin\metadppc.exe helloworld1.dpp<br /></span></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>C:\LayerD\bin\metadppc.exe helloworld2.dpp<br /></span></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>C:\LayerD\bin\metadppc.exe helloworld3.dpp<br /></span></p><p>Take into account that this is possible because the program analysis and code generation is implemented in the Zoe compiler and not in the Meta D++ compiler.<br /></p><p><strong>Zoe Compilation<br /></strong></p><p>When you have the .zoe files of your program you must compile them with "zoec.exe" compiler. If the program is composed of one file:<br /></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>zoec.exe HelloWorld.zoe<br /></span></p><p>That will generate an .exe file for .NET platform that is the default platform and module type.<br /></p><p>If the program is composed of more than one file:<br /></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>zoec.exe HelloWorld_Source1.zoe HelloWorld_Source2.zoe –pn:HelloWorld<br /></span></p><p>The parameter "-pn:HelloWorld" set the output filename for the generated module, this is required when more than one file is provided for compilation. If your program is composed of only one file and you don't provide the "-pn" parameter then the filename of the sourcefile will be used for the module name.<br /></p><p><strong>All steps together<br /></strong></p><p>As you need to run Meta D++ compiler and Zoe compiler to get the executable/library these are all the steps together:<br /></p><p>For a program composed of one source file:<br /></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>metadppc.exe HelloWorld.dpp<br /></span></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>zoec.exe HelloWorld.zoe<br /></span></p><p>For a program composed of more than one source file:<br /></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>metadppc.exe HelloWorld_Source1.dpp<br /></span></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>metadppc.exe HelloWorld_Source2.dpp<br /></span></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>zoec.exe HelloWorld_Source1.zoe HelloWorld_Source2.zoe –pn:HelloWorld<br /></span></p><p> Take into account that there will be more than one high level LayerD language (in addition to Meta D++), the Zoe compiler is always used in the same form.<br /></p><p><strong>Generation of Dynamic libraries (.dll)<br /></strong></p><p>To compile dynamic libraries use the parameter "-lib":<br /></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>metadppc.exe HelloWorldLib.dpp<br /></span></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>zoec.exe HelloWorldLib.zoe –lib<br /></span></p><p><br /> </p><p><strong>To compile a Compile Time extension<br /></strong></p><p>Compile the extension source code:<br /></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>metadppc.exe MyClassfactory.dpp<br /></span></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>zoec.exe MyClassfactory.zoe –ae<br /></span></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>Extension Added: MyClassfactory<br /></span></p><p>Not special step required for client code, compile as always:<br /></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>metadppc.exe MyClassfactoryClient.dpp<br /></span></p><p style='background: #f2f2f2'><span style='font-family:Courier New'>c:\layerd\bin>zoec.exe MyClassfactoryClient.zoe<br /></span></p><p><br /> </p><p>More information on the wiki:<br /></p><p><a href='http://layerd.wiki.sourceforge.net/compiler_usage'>http://layerd.wiki.sourceforge.net/compiler_usage</a><br /> </p><p>And on the command line help of the metadppc and zoec compilers.</p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-75058354254647873022009-05-24T20:57:00.001-03:002009-05-24T20:57:14.507-03:00LayerD Wiki<span xmlns=''><p>I've started the LayerD Wiki page here:<br /></p><p><a href='http://layerd.wiki.sourceforge.net/'>http://layerd.wiki.sourceforge.net/</a><br /> </p><p>If you know something about LayerD maybe you can contribute :-).<br /></p><p>It's very small for now but I will be updating :-P.<br /></p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-13345041584406041062009-05-03T21:43:00.002-03:002009-05-03T22:25:58.210-03:00LayerD SDK 0.5.2 - Now you can do Java compile time programming :-)<p>I'm releasing a new SDK (here <a href="http://sourceforge.net/projects/layerd">sourceforge</a>) that contains reference guides and a Zoe Code Generator for Java language, so you can do compile time programming for Java :-). It's alpha code and do not support things like generics, annotations or non-static inner classes but you can generate a lot of code on compile time :-), and play with new semantic structures or RAD tools using interactive compilation.<br /><br />Here the readme of the SDK:<br /></p><h2>LayerD SDK Release Alpha 0.5.2<br /></h2>This SDK version Alpha 0.5.2 includes the following components:<br /><ul><li>Meta D++ compiler</li><li>Zoe compiler</li><li>Zoe Code Generator for .NET</li><li>Zoe Code Generator for Java</li><li>Interactive Zoe Code Generator for Meta D++</li><li>Sample extensions to Zoe compiler</li><li>Zoe CodeDOM and Compiler documentation generated from code ( <a href="http://www.blogger.com/docs%5CCodeDOM-Reference%5Cindex.html">\doc\CodeDOM-Reference\index.html</a> )</li><li>Meta D++ programming guide for .NET programmers, Spanish only ( <a href="http://www.blogger.com/docs%5CInstructivo%20de%20LayerD%20para%20dotNET.pdf">\docs\Instructivo de LayerD para dotNET.pdf</a> )</li><li>Meta D++ Programmers Guide, Spanish only (Manual de Usuario Meta D++), ( <a href="http://www.blogger.com/docs%5CManual%20de%20Meta%20D++%20v1.0.0.pdf">\docs\Manual de Meta D++ v1.0.0.pdf</a> )</li><li>Sample programs (\Samples)<br /></li></ul><h2>Hardware Requirements</h2>Even when any PC that can run Windows will work properly these are recommended specs:<br /><ul><li>512MB RAM<br /></li><li>Processor: 1.5GHz AMD/INTEL<br /></li><li>Hard disk space :-).<br /></li></ul>It’s not recommended to run LayerD compilers from network or pendrives because of temporal files created could degrade compilers performance.<br /><h2>Software Requirements</h2><ul><li>Windows 2000/2003/XP/Vista (not tested on Windows 95/98)<br /></li><li>Microsoft .NET SDK 2.0 or greater.<br /></li><li>Java SDK 1.4 or greater to generate Java programs. (not mandatory, only to use Java Code Generator).<br /></li><li>Others SDK can be needed depending on target programs (for example .NET Compact Framework SDK for mobile applications).<br /></li></ul><h2>Quick start</h2>To make programs on LayerD framework you must make the programs on one high level language (currently Meta D++, also there is a Java clon that is distributed separately). After that, you must compile Meta D++ source code using metadppc.exe compiler and the generated .zoe files with zoec.exe compiler. Check the instructions on Meta D++ Programmers Guide.<br />It’s recommended to read the Meta D++ programming guide for .NET programmers even if you don’t program for that platform because of generic concepts explained in this document. There isn’t an IDE currently available. I use Notepad++ editor or Visual Studio and have custom macros that call compilers. You can use any text editor.<br /><strong>Note:</strong> There is plug-in for Visual Studio that implements a kind of “Intellisense”; it’s only a concept and don’t work on programs that have more than one file but it can be useful (on files with less than 1500 lines of code :-P ).<br />More information on: <a href="http://layerd.net/">http://layerd.net</a>, <a href="http://layerd.blogspot.com/">http://layerd.blogspot.com</a>, <a href="http://sourceforge.net/projects/layerd">http://sourceforge.net/projects/layerd</a>.<br /><br />Please don’t hesitate to contact me at mailto:alexis.ferreyra@yahoo.com for information or if you want to contribute with the project.<br /><h2>Debugging<br /></h2>Programs can be debugged using standard infrastructure of the target platform. For example, if you program for .NET you can use Visual Studio or SharpDevelop for debugging. If you develop for Java take into account that Zoe Code Generator for Java is Alpha version and don´t generate equivalence between Meta D++ source code and generated Java code, so it will be a bit more challenging but you can use any Java IDE to debug generated code, frequently visit LayerD’s website because this module will be updated frequently.<br /><p>To debug classfactorys (compile time functionality) you can use –wfd flag on zoec.exe compiler the compiler will wait until a compiler attaches to the compiler process before continue. So you can run the compilation with –wfd flag and attach to zoec.exe process from a debugger like Visual Studio (first set breakpoints on compile time source code).<br /></p><h2>Languages features implemented on this SDK</h2>LayerD is a large, ambitious and little complex project so not all desired features of Meta D++, Zoe, and Zoe Code Generators are implemented. Currently these are the features included until now:<br /><ul><li>Main features of Zoe and Meta D++ languages to support standard object oriented programming like classes, interfaces, single inheritance, enumerations and statements.<br /></li><li>Compilation of Classfactorys, standard and interactive.<br /></li><li>Multiple compile times on Zoe compiler.<br /></li><li>Interactive compilation for Meta D++ language.<br /></li><li>Generation of .NET assemblies for desktop and mobile, .exe and .dll.<br /></li><li>Generation of .class files for Java (using javac compiler)<br /></li><li>Automated import of types for .NET platform but not including generic types, nulleables and attributes.<br /></li><li>Automated import of types for Java platform but not including generic types or annotations.<br /></li></ul><h2>Languages features NOT IMPLEMENTED on this SDK</h2>These are the desired features of languages and code generators not implemented in this SDK:<br /><ul><li>keyword modifier on classfactory members<br /></li><li>setplatforms directive on classfactorys members<br /></li><li>“hybrid” classfactorys<br /></li><li>“auto instantiation” of classfactorys<br /></li><li>calls blocking semantic on classfactorys (to warranty that all instance members of one classfactory will be executed on the same compile time or skipped to next compile time).<br /></li><li>automatic re-composition of classfactorys<br /></li><li>classfactorys that depends on other classfactorys currently installed on Zoe compiler<br /></li><li>import of generics types and attributes/annotations on .NET and Java<br /></li><li>homogenization of base types (for Java)<br /></li><li>some kind of semantic checks are not currently implemented by Zoe compiler like requiring return instructions on all code paths, this checks are implemented by lower level compilers on code generators for .NET or Java, but the required behavior is to be controlled on Zoe compiler.<br /></li><li>annotations or attributes are not implemented on Zoe or Meta D++ (even when it can be imitated by classfactorys)<br /></li><li>generation of “Extended Zoe” is not implemented on Zoe compiler, so code generator for java, for example, can’t implement custom operators or properties.<br /></li><li>multiple inheritance is not implemented<br /></li><li>forced member virtualization is not checked by Zoe compiler<br /></li><li>Meta D++ compiler doesn’t support Unicode files, only ASCII, but it must support Unicode :-P<br /></li><li>support for more than one XML namespace on Zoe files<br /></li></ul><h2>Documentation</h2><ul><li>Zoe CodeDOM and Compiler documentation generated from code ( <a href="http://www.blogger.com/docs%5CCodeDOM-Reference%5Cindex.html">\doc\CodeDOM-Reference\index.html</a> )<br /></li><li>Meta D++ programming guide for .NET programmers, Spanish only ( <a href="http://www.blogger.com/docs%5CInstructivo%20de%20LayerD%20para%20dotNET.pdf">\docs\Instructivo de LayerD para dotNET.pdf</a> )<br /></li><li>Meta D++ Programmers Guide, Spanish only (Manual de Usuario Meta D++), ( <a href="http://www.blogger.com/docs%5CManual%20de%20Meta%20D++%20v1.0.0.pdf">\docs\Manual de Meta D++ v1.0.0.pdf</a> )<br /></li></ul><h2>Know bugs</h2>As this is an alpha release it has several know bugs most important ones:<br /><ul><li>Sometimes you will get several errors that said something like “__error type is not found”. Rebuild the file with Zoe compiler and will fix the error.<br />If you find errors on Meta D++ compiler or Zoe compiler (even if you are not sure) please let me know about that and if you can send to me the source that generate the error.<br /></li> </ul><h2>LayerD SDK FAQ</h2><span style="font-weight: bold;">Why is this SDK in mixed English / Spanish ?</span><br /><p>Because I don't have time to maintain both English and Spanish SDK. So, I'm translating all to English. If you want to help me that will be great!!<br /></p><span style="font-weight: bold;">There is a distribution for Linux ?</span><br /><p>No, there isn't. It's perfectly possible to compile all modules in Linux but I don't have time to do that and I use Windows more than Linux. May be you can help me with this task.<br /></p><span style="font-weight: bold;">Can be used to develop commercial applications ?</span><br /><p>Yes, In fact it was used for at least two pretty big commercial projects (both on .NET). Please let me know if you use LayerD on a commercial project !<br />You don't have to pay me for that, this is a free and open source project. If you make money consider a donation :-)<br /></p><br /><strong><br />Thanks for downloading LayerD SDK,<br />Be happy doing compile time programming :-)<br /><br />Distribution date: May 3, 2009</strong>Alexis Ferreyrahttp://www.blogger.com/profile/14282185824248514317noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-31190294641708053002009-05-03T21:36:00.002-03:002009-05-03T21:41:33.696-03:00LayerD documentationI'm releasing a new SDK that contains a Programmers Reference Manual for Meta D++ and a revised guide to Compile Time programming for .NET programmers.<br />This reference manual is only in Spanish and was made by Belén Licari, thanks Belén! I've revised most of it and it seems ok ! I will update the manual if I find mistakes.<br />This is not much documentation taking into account the extension of the project but it's something :-). If someone can help me translating this documentation to English it will be great!!Alexis Ferreyrahttp://www.blogger.com/profile/14282185824248514317noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-2391383928322041012009-04-21T22:30:00.008-03:002009-04-21T22:49:22.728-03:00Interactive compilation and RAD tools with LayerD<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg3BWCEtU7FAavbCQBQ7DQ2MRJNRuGyR5SMj6AljKu3viaV5Qn2cTkbvOcBEluOBmEy5NO4Zv74ERI2pCaSzsp1nnJd07Kdv-U_6ltf1pQ984_7dzmnfRLxZ7JKHLBCO87RNCjNroZpsVCc/s1600-h/Diapositiva1.JPG"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 400px; height: 300px;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEg3BWCEtU7FAavbCQBQ7DQ2MRJNRuGyR5SMj6AljKu3viaV5Qn2cTkbvOcBEluOBmEy5NO4Zv74ERI2pCaSzsp1nnJd07Kdv-U_6ltf1pQ984_7dzmnfRLxZ7JKHLBCO87RNCjNroZpsVCc/s400/Diapositiva1.JPG" alt="" id="BLOGGER_PHOTO_ID_5327322211049720066" border="0" /></a><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjZiYa9WbC5nKbhRXLPHQb8chPoM7YnASfcpPBW9b_rCoFB41QAYn8-jY4_TzG2qhlrgCk9315E_PxxxMouthbM1ttX80Ioz5jfMDV9L93FMDTbZKGoK0x7vX2pq9tpSj2r1DWn92ZdFHwQ/s1600-h/Diapositiva2.JPG"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 400px; height: 300px;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjZiYa9WbC5nKbhRXLPHQb8chPoM7YnASfcpPBW9b_rCoFB41QAYn8-jY4_TzG2qhlrgCk9315E_PxxxMouthbM1ttX80Ioz5jfMDV9L93FMDTbZKGoK0x7vX2pq9tpSj2r1DWn92ZdFHwQ/s400/Diapositiva2.JPG" alt="" id="BLOGGER_PHOTO_ID_5327322354845125746" border="0" /></a><br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgjmY0SWPg2Iw26cZ07_X_UeBpCWWQTiKYxZJ_sFtYf6PkbfzT1-lgSNVpFeVhB7ATcKClujzeiDZLLsX_9lAO2_EyKXchP_V4iJ9BQmD_gaRtxWPYDcj3tA3-pI8i1D0wkmey4FpZluq5R/s1600-h/Diapositiva3.JPG"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 400px; height: 300px;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEgjmY0SWPg2Iw26cZ07_X_UeBpCWWQTiKYxZJ_sFtYf6PkbfzT1-lgSNVpFeVhB7ATcKClujzeiDZLLsX_9lAO2_EyKXchP_V4iJ9BQmD_gaRtxWPYDcj3tA3-pI8i1D0wkmey4FpZluq5R/s400/Diapositiva3.JPG" alt="" id="BLOGGER_PHOTO_ID_5327322495587023154" border="0" /></a><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi5FBmzhElXIjQFfbCSAoOR-c8XsrvYxOK7ZxKpH1XsZdfwoQIqR1jwBFcqa0OtTqkZXwxh9Jy6k4j4rM8t8uc_jfrAmI7wdpAKqv-wLOI_q0iGsxx9RqKnU_CtfN2fSscwXSXus0ev45bo/s1600-h/Diapositiva4.JPG"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 400px; height: 300px;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEi5FBmzhElXIjQFfbCSAoOR-c8XsrvYxOK7ZxKpH1XsZdfwoQIqR1jwBFcqa0OtTqkZXwxh9Jy6k4j4rM8t8uc_jfrAmI7wdpAKqv-wLOI_q0iGsxx9RqKnU_CtfN2fSscwXSXus0ev45bo/s400/Diapositiva4.JPG" alt="" id="BLOGGER_PHOTO_ID_5327322720670105986" border="0" /></a><br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhDaGB0sSUdMFzQcAija-inHUWWAm1fpxhs8rLvrj-VzVqAz-QP88zExZJMvWPgzdRvz4PGNSPiYitwAruFTzXk6UJlmA6PfIBQaL1BKWu1KZMqB16UAxlW5vPGANBjj7TjVEJ58fYhBw7X/s1600-h/Diapositiva5.JPG"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 400px; height: 300px;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhDaGB0sSUdMFzQcAija-inHUWWAm1fpxhs8rLvrj-VzVqAz-QP88zExZJMvWPgzdRvz4PGNSPiYitwAruFTzXk6UJlmA6PfIBQaL1BKWu1KZMqB16UAxlW5vPGANBjj7TjVEJ58fYhBw7X/s400/Diapositiva5.JPG" alt="" id="BLOGGER_PHOTO_ID_5327322852379019682" border="0" /></a><br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj-YYSvnaXU8AoNobW_HL7AWTeT6UGaUouVubAKyWI4HiJ21kgr_gnU_YcYOSMOhfWFYsjweY90qwRaCBwgZafh4RJoQyHBpxavb3dWR-C89wS5SI-E9EYyE5PV1-VyAGCMrEw99ofqpFMB/s1600-h/Diapositiva6.JPG"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer; width: 400px; height: 300px;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEj-YYSvnaXU8AoNobW_HL7AWTeT6UGaUouVubAKyWI4HiJ21kgr_gnU_YcYOSMOhfWFYsjweY90qwRaCBwgZafh4RJoQyHBpxavb3dWR-C89wS5SI-E9EYyE5PV1-VyAGCMrEw99ofqpFMB/s400/Diapositiva6.JPG" alt="" id="BLOGGER_PHOTO_ID_5327322965036703522" border="0" /></a><br /><span style="font-weight: bold;">PD:</span> new SDK coming soon: classfactory debugging, several bug fixes, Java to Meta D++ compiler, basic manual about OO in Meta D++ (in Spanish), more samples.<br /><br /><span style="font-weight: bold;">PD2: </span>I know, this is English... I don't have time to write both Spanish and English so I have to make a choice. ... In fact I don't have time to write in one single language :-PAlexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-62573071931643486242009-02-18T18:54:00.001-02:002009-02-18T18:54:03.835-02:00Principles of Programming Research in the Computer Science Department at Carnegie Mellon<span xmlns=''><p>Un extracto que me pareció interesante de la carta de presentación del centro de investigación en programación (lenguajes) de la universidad de Carnagie Mellon:<br /></p><p><span style='font-family:Times New Roman; font-size:12pt'><em>"Our success in advancing an integrated view of Computer Science encourages us to take on even greater challenges, and opens up many new possibilities for us to explore. We envision that future languages will have fully formal definitions with fully checked proofs of their safety and security properties as a matter of course. Currently available tools, such as Twelf, are already expressive enough to make this feasible for realistic languages such as the POPLMark Challenge (posed by Pierce and others at UPenn) and large fragments of the ML language. Research is already under way on enriching their expressive power and convenience to make the task simpler, more modular, and easier to maintain and evolve. In particular we envision the development of logical frameworks that support a more direct and natural representation of shared state and of concurrent interaction than is currently feasible.<br /></em></span></p><p><span style='font-family:Times New Roman; font-size:12pt'><em>Our experience with the design and implementation of certifying compilers emboldens us to assert that in the future all compilers will be certifying compilers that will make use of expressive type systems in intermediate and object code, as well as source languages. Compilers are very complex software systems that are notoriously difficult to maintain and evolve. Certification permits a degree of self-checking within a compiler that greatly increases the modularity of the compiler itself, and correspondingly vastly enhances our ability to make significant changes to a component without disrupting crucial invariants assumed by other components. Moreover, certifying compilers generate object code that carries with it a machine-checkable proof of safety and security properties, eliminating or greatly reducing the need to rely on the correctness of a compiler to ensure the well-behavior of a binary executable.<br /></em></span></p><p><span style='font-family:Times New Roman; font-size:12pt'><em>The effectiveness of type systems for improving code quality, reducing development costs, and enhancing maintainability of software is by now beyond dispute. We believe that the trend toward languages with increasingly expressive type systems will accelerate, and that the demands for type systems of ever-greater expressive power will increase as developers become accustomed to their use. In the near future we expect to see type systems that are capable of expressing, and mechanically enforcing, crucial data structure and protocol invariants across module boundaries. In the longer term we expect a convergence of type systems and specification languages to achieve a complete integration of these important tools for reasoning about program behavior. There is every reason to pursue these goals aggressively, and we are optimistic that the foundation of tools and theories that we have developed will serve as a solid basis for this work.<br /></em></span></p><p><span style='font-family:Times New Roman; font-size:12pt'><em><strong>Speaking more broadly, we believe that it is time to challenge the prevalent, if tacit, assumption that we must live with low-quality, unreliable software that is prohibitively expensive to improve, much less replace. Rather than accept the status quo and try to live with it, we do better to challenge it and try to do better. It is our contention that a comprehensive approach based on the application of fundamental theory to programming practice is the best strategy for overcoming the limitations of current software systems and practices.</strong>"<br /></em></span></p><p><span style='font-family:Times New Roman; font-size:12pt'>Link: <a href='http://www.csd.cs.cmu.edu/research/areas/principleprogr/'>http://www.csd.cs.cmu.edu/research/areas/principleprogr/</a><br /> </span></p><p><span style='font-family:Times New Roman; font-size:12pt'><br /> </span> </p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-11931979261363976822009-01-21T18:39:00.001-02:002009-01-21T18:46:48.494-02:00Compiler research: the next 50 years<span xmlns=''><p>Este post no tiene que ver directamente con LayerD pero me pareció interesante compartir algunas partes de un interesante artículo titulado "Compiler research: the next 50 years" de la respetada publicación "ACM communications volume 52 issue 2". Transcribo las partes que me parecieron más interesantes:<br /></p><p><br /> </p><p><em>Today, compilers and highlevel languages are the foundation of the complex and ubiquitous software infrastructure that undergirds the global economy. It is no exaggeration to say that compilers and high-level languages are as central to the information age as semiconductor technology. <br /></em></p><p><em>In the coming decade, 2010 to 2020, compiler research will play a critical role in addressing two of the major challenges facing the overall computer field: Cost of programming multicore processors and Security and reliability of complex software systems.<br /></em></p><p><strong><em>Cultural Shift<br /></em></strong></p><p><em>To address these challenges, the compiler community must change its current research model, which emphasizes small-scale individual investigator activities on one-off infrastructures. Complete compiler infrastructures are just too complex to develop and maintain in the academic research environment.<br /></em></p><p><em>Exploiting large-scale parallel hardware will be essential for improving an application's performance or its capabilities in terms of execution speed and power consumption. The challenge for compiler research is how to enable the exploitation of the power of the target machine, including its parallelism, without undue programmer effort.<br /></em></p><p><em>Enable the creation of compiler research centers. There are few large compiler research groups anywhere in the world today. At universities, such groups typically consist of a senior researcher and a few students, and their projects tend to be short term, usually only as long as a Ph.D. project. Meanwhile, the few industrial groups studying advanced compiler technology tend to focus on near-term solutions, even as the compilers, the programs they translate and analyze, and the target execution environments have increased in complexity. The result is that too much of today's compiler research focuses on narrow problems, ignoring the opportunity to develop revolutionary strategies requiring long-term commitment for their development and evaluation.<br /></em></p><p><em>The computer science community has achieved notable success in developing novel compiler infrastructures, including: compiler front-end development; program-analysis frameworks for research in compilers; verification tools, security applications, and software-engineering tools; and virtual machine frameworks for both mainstream and special-purpose languages. Even if the GNU and industry-developed compilers were a useful infrastructure for research, development of new robust, easy-to-use infrastructures by the researchers who need them are critical for future advances. Not only is it important to support such research projects, the research community must recognize their academic merit.<br /></em></p><p><em>Compiler courses must clearly demonstrate to students the extraordinary importance, range of applicability, and internal elegance of what is one of the most fundamental enabling technologies of computer science.<br /></em></p><p><em>Knowledge of the power and limitations of compiler algorithms is valuable to all users of compilers, debuggers, and any tool built using compiler algorithms that encapsulate many, if not most, of the important program-analysis and transformation strategies necessary for performance and correctness. Therefore, learning about compiler algorithms leads to learning about program optimization and typical programming errors in a deep and rigorous manner. For these reasons, programmers with a solid background in compilers tend to excel in their profession.<br /></em></p><p>Definitivamente sería bueno que todo programador alguna vez construya su propio lenguaje de juguete aunque más no sea. Hoy por hoy hay muchas herramientas como para que esto sea una tarea más de tener ganas que de saber mucho para construir algo sencillo. Claro, si se quiere avanzar para abarcar lenguajes completos la dificultad y tiempo necesario aumenta mucho pero sigue siendo como todo una cuestión de ponerle laburo. En este sentido LayerD puede ser usado muy bien como herramienta didáctica para enseñar sobre compiladores ya que escribir un lenguaje LayerD de alto nivel es una tarea que se puede automatizar con cosas como Bison o JavaCC, para la etapa intermedia se puede usar el compilador Zoe que nos librara de la tarea de tener que diseñar y construir un analizador semántico a mano (cosa que suele ser lo más "complicado/laborioso" de un compilador por no haber prácticamente herramientas). Si se desea alterar la semántica de Zoe se puede modificar el código fuente en casos de querer cambiar mucho la semántica, o simplemente escribir un par de extensiones con classfactorys para cambios o incorporaciones no tan drásticas. Finalmente la generación de código se puede usar o modificar alguno de los generadores de código Zoe que hay. <br /></p><p>Ojala, como dice el artículo se le dé más importancia a la investigación en relación a compiladores y en la próxima década veamos avances emocionantes al respecto. Personalmente, opino que son mucho más importantes los cambios y avances a realizar en lo que respecta al diseño de lenguajes de alto nivel que lo relacionado a mejorar los generadores de código de bajo nivel. Si bien coincido en que la generación de código optimizado y eficiente es clave, también pienso que es mucho más favorable para la ciencia de la computación y la industria del software cada vez que se logra elevar el nivel de abstracción en el desarrollo de software. Los primeros compiladores no generaban código super optimizado, sin embargo la ventaja de poder programar en un nivel de abstracción más alto le garantizo el éxito a los compiladores. El éxito de entornos de ejecución como Java y .NET no fue porque sus primeros intérpretes fueran excelentes, sí por poseer la capacidad de facilitar el desarrollo y mantenimiento del software.<br /></p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-19672683110203361482008-11-11T20:06:00.001-02:002008-11-11T20:10:32.663-02:00LayerD es proyecto oficial<span xmlns=''><p>En estos días tuve la grata noticia de poder confirmar a LayerD como proyecto de investigación oficial reconocido por la Secretaria de Ciencia y Tecnología (SCyT) de la Universidad Tecnológica Nacional.<br /></p><p>Por esto debo agradecer nuevamente al Ing. Juan Carlos Vazquéz por haberme incentivado a llevar el proyecto al laboratorio de la facultad y a todas las personas que me ayudaron en el transcurso de su ejecución. También al Dr. Ricardo Medel por aceptar ser director de la mencionada oficialización del proyecto.<br /></p><p>Es muy grato haber podido, aún en una etapa relativamente temprana de su desarrollo, utilizar las herramientas y lenguajes desarrollados ya en dos proyectos comerciales, también ejecutados dentro del ámbito de Laboratorio de Investigación de Software de la Regional Córdoba como son los proyectos Janus (realizado para la mismísima Microsoft directamente) y Transito (desarrollo que se está llevando a cabo para el Gobierno de la Provincia de Córdoba).<br /></p><p>Creo que voy a tener un poco más de tiempo en lo subsiguiente, por tanto espero poder publicar más cosas incluyendo manuales y un SDK actualizado en estos meses finales del 2008.<br /></p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-74234490984721719652008-10-19T02:04:00.003-02:002008-10-19T02:14:33.403-02:00El LayerD de las eminencias<span xmlns=""><p>Me agrada muchísimo enterarme – lamentablemente recién ahora – del trabajo de eminencias mundiales en ciencias de la computación como son:</p><ul><li>Alan Kay : Creador de Smalltalk, Simula, uno de los padres inventores de la orientación a objetos en los 70, Ganador del premio Turing (para quienes no conocen son como los premios nobel en las ciencias de la computación)… bue si no sabes quién es Alan Kay se merece lo "googlees".<br /></li><li>Dan Ingalls: Colaborador de Alan Kay en los míticos Xerox PARC implemento el primer compilador de Small Talk, trabajo en los equipos que inventaron las primeras UI de la historia, en los laboratorios de HP, entro otros trabajos.</li><li>Yoshiki Ohshima, Ian Piumarta, Andreas Raab: Todos ellos conocidos científicos de ciencias de la computación con docenas de trabajos publicados en los congresos "top" como los organizados por el ACM.</li></ul><p>Entre otros colaboradores están desarrollando el proyecto "Steps Toward the Reinvention of Programming" el cual intenta resolver muchos de los problemas existentes en la ingeniería de software planteando (humildemente al igual que lo afirmo e intento colaborar proponiendo soluciones con LayerD) las limitaciones del software actual y sus problemas de implementación como el "bloated code", la fragilidad del software, la escasa expresividad de los programas, las limitaciones de acoplamiento del código fuente actual entre otros problemas.<br /></p><p>Aún no he tenido tiempo de estudiar este proyecto en profundidad pero por lo que he leído es muy ambicioso y no abarca sólo la etapa de implementación.</p><p>Me resulto muy grato como para la etapa de implementación del software planean (y utilizan) mecanismos muy similares a los que uso en LayerD:<br /></p><p><span><span xmlns=""><span xmlns=""><span xmlns=""><span><span xmlns=""><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjbQRvMDPTkwC-k3g2_dojl363brWrV7rbIAw6uoC_lWCiMiXpRV7cMhIxI-oZN1Qn12U0o5JrKXPFtldWV9bvUIiVh24VUAZBlyeGmn_wvD329Dut8EfCfeGFJbnP9GDsjQY0nb7MGK0hyphenhyphen/s1600-h/Dibujo.jpg"><img style="margin: 0px auto 10px; display: block; text-align: center; cursor: pointer;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjbQRvMDPTkwC-k3g2_dojl363brWrV7rbIAw6uoC_lWCiMiXpRV7cMhIxI-oZN1Qn12U0o5JrKXPFtldWV9bvUIiVh24VUAZBlyeGmn_wvD329Dut8EfCfeGFJbnP9GDsjQY0nb7MGK0hyphenhyphen/s320/Dibujo.jpg" alt="" id="BLOGGER_PHOTO_ID_5258712022388101122" border="0" /></a></span></span></span></span></span></span> </p><p>La diferencia principal de su método (principalmente está detrás de esta parte Ian Piumarta parece ser) es que utilizan lenguajes dinámicos en tiempo de compilación y ejecución. También tiene en común como tratan y hablan del problema de los lenguajes y tecnologías actuales de desarrollo en cuanto al acoplamiento a los entornos de ejecución, librerías y hardware (el ambiente) y señalan que es necesario eliminar estas limitaciones para poder "reinventar la programación". En definitiva, se trata de un proyecto que tiene mucho en común filosóficamente hablando con LayerD aunque la implementación sea diferente en varios sentidos y común en algunos otros.<br /></p><p>No es la primera vez que encuentro que existe algún proyecto "filosóficamente" similar a LayerD, de hecho es algo que se viene buscando hace mucho tiempo lograr. Anteriormente tenía conocimiento de proyectos similares como el empuje de la Programación Orientada al Lenguaje por tipos como Sergey Dmitriev y la programación intencional impulsada por el mítico Charles Simonyi (Xerox, Microsoft, Intentional Programming); aunque estos autores no hablan demasiado del acoplamiento del software a APIs y entornos de ejecución, lo cual para mi es fundamental erradicar, sino que hablan más de utilizar paradigmas más abstractos.<br /></p><p>LayerD se desarrollo en su formato actual alrededor de fines del año 2002, es muy grato para mi saber que aún cuando no conocía nada de estos proyectos, meta-programación, programación orientada al lenguaje o programación intencional, haya llegado a desarrollar algo muy similar a las tecnologías que estas eminencias ganadoras de premios Turing y repletas en PhD, Masters y cosas por el estilo. Me da esperanzas porque me hace pensar que en la próxima década definitivamente veremos nacer un nueva era en la ingeniería de software de la mano de algunos de estos proyectos y saber que humildemente forme parte de uno de ellos que impulsa con pasión hacia ese destino inevitable de nuestra querida profesión me hace sentir bien y tener la certeza de que no perdí el tiempo todos estos años que tanto esfuerzo – a pesar de mis limitaciones, ignorancia y falta de experiencia – puse en este proyecto.<br /></p><p>Les dejo algunos links, y sigo estudiando :-P<br /></p><p><a href="http://www.vpri.org/html/work/NSFproposal.pdf">http://www.vpri.org/html/work/NSFproposal.pdf</a><br /> </p><p><a href="http://piumarta.com/papers/colas-whitepaper.pdf">http://piumarta.com/papers/colas-whitepaper.pdf</a><br /> </p><p><a href="http://vpri.org/html/work/ifnct.htm">http://vpri.org/html/work/ifnct.htm</a><br /> </p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-88288572356744172202008-10-05T22:31:00.004-03:002008-10-05T23:03:20.782-03:00Hablemos de Ingeniería<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhSdHtzvnTH3OKGW5Izlfa2qCbG7F_tWx6fbSTb2Q-BGAVCcwMUAYkmZ5KTwbLHhvL9VuXzLGJU-LLbu3RCnDL212aJJtZcO7tK1679gSS4iDYmyBoxaXwUuAL0dW-epG2JQhiBEoPPjsW5/s1600-h/Dibujo.jpg"><img style="margin: 0pt 10px 10px 0pt; float: left; cursor: pointer;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhSdHtzvnTH3OKGW5Izlfa2qCbG7F_tWx6fbSTb2Q-BGAVCcwMUAYkmZ5KTwbLHhvL9VuXzLGJU-LLbu3RCnDL212aJJtZcO7tK1679gSS4iDYmyBoxaXwUuAL0dW-epG2JQhiBEoPPjsW5/s320/Dibujo.jpg" alt="" id="BLOGGER_PHOTO_ID_5253854528118372050" border="0" /></a><br /><br />El viernes pasado dí una pequeña charla en el Laboratorio de Investigación de Software de mi facultad (<a href="http://www.frc.utn.edu.ar/">UTN - FRC</a>) y duro poco más de hora y cuarto.<br /><br />El objetivo era dar una introducción al proyecto LayerD a quienes no lo conocían.<br /><br /><br />Los temas de la charla fueron:<br /><br /><ul><li><span style="font-weight: bold;">¿Qué es LayerD?</span> : una introducción en dos minutos explicando que se trata básicamente de lenguajes de programación con algunas características "novedosas" como compiladores multi-stage, extensibles y modulares.</li><li><span style="font-weight: bold;">Motivaciones del Proyecto :</span> se explico como se tuvieron en cuenta los problemas actuales a la hora de implementar software, lo que se espera para el hardware de las proximas decadas y el software que se viene en los proximos años. Todo ello influyo en el diseño de LayerD.<br /></li><li><span style="font-weight: bold;">Hablemos de Ingeniería :</span> a lo largo del tiempo aprendi que no es sencillo explicar el framework LayerD y menos justificar sus características simplemente nombrandolas, por lo tanto me tome la mayor parte de la charla para hablar sobre ingeniería de software, compararla con otra ingeniería (civil) y analizar las limitaciones y frustraciones actuales de nuestra querida profeción, también introducir sobre como sobrellevar estas límitaciones. Se introdujo al tema de diseñar lo que llamo arquitecturas "bidimensionales" de software, donde no sólo se tiene en cuenta la "dimensión de tiempo de ejecución" (es decir todo lo que sucede cuando el software se esta ejecutando) sino también empezar a considerar la existencia de otra dimensión la "dimesión física". Aplicar tecnicas conocidas de diseño como la separación en capas también en esta dimensión física del software nos permite elevar considerablemente su nivel de abstracción y abrir la puerta para una mayor reutilización, tiempo de vida y menores costos de mantenimiento del software.<br /></li><li><span style="font-weight: bold;">Paradigmas al Vuelo :</span> se hablo rápidamente del impulso que se le esta dando a "nuevos" (no tanto) paradigmas que impulsan el desarrollo de software más abstracto como la orientación al lenguaje, programación declarativa, lenguajes de dominio especifico, programación intencional, model driven development, etc. Y como con LayerD es posible implementar software bajo estos paradigmas.<br /></li><li><span style="font-weight: bold;">El Diseño de LayerD :</span> Se explico brevemente el diseño y como todo encaja con los requerimientos y los problemas existentes en la ingenieria de software. Si todo salio como esperaba, se mostro porque LayerD tiene el diseño que tiene y como cada pieza y funcionalidad es necesaria.<br /></li><li><span style="font-weight: bold;">Ejemplos : </span>Se mostraron diversos ejemplos.<br /></li><li><span style="font-weight: bold;">El Futuro / Lo pendiente :</span> Se hablo de toda la inmensa lista de pendientes dentro del proyecto y como esto es apenas un punto de partida. Se invito a quienes quieran participar a ayudar a completar el proyecto o tomar lo aprendido para sus propios proyectos.<br /></li></ul>Para quienes le interese dejo <a href="http://layerd.net/blog/Introduccion_al_Proyecto_LayerD_LIS_UTN_2008.zip">las diapositivas aquí</a> (no son tan interesantes sin el "speech" supongo je). Por cierto, si sos de la UTN recorda que todos los viernes estamos dando charlas en nuestro laboratorio, además compartimos galletas y café. Seas o no alumno de la UTN podes entrar a nuestra <a href="http://utnlis.ning.com/">pequeña red social</a> para enterarte de varias cosas que pasan en nuestro laboratorio.<br /><br />Ya no pongo fechas (demasiado trabajo y terminando de cursar) pero en cualquier momento publico los manuales y actualizo la documentación además del SDK y los fuentes publicos.<br /><br />Saludos.Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-20690185455272641512008-08-07T23:20:00.001-03:002008-08-07T23:24:38.413-03:00Programación Concurrente con LayerD<span xmlns=''><p>Los lenguajes LayerD actuales no definen prácticamente ninguna librería de base. Esto no es sin embargo un problema ya que LayerD está diseñado para utilizar la infraestructura de los entornos de ejecución y librerías actuales como ensamblados .NET o cualquier librería Java.<br /></p><p>Naturalmente se puede programar sistemas concurrentes usando las librerías disponibles en las plataformas que soporten los Generadores de Código Zoe de los cuales dispongamos. Adicionalmente, y quizás mucho más interesante, al ser Meta D++ un lenguaje "extensible" (a través de classfactorys y gracias al lenguaje intermedio Zoe) es posible desarrollar "estructuras" que nos permitan programar este tipo de sistemas de manera más sencilla.<br /></p><p>A modo de ejemplo posteo uno de los escuetos ejemplos del SDK donde se muestra una sencilla estructura que permite ejecutar una secuencia de instrucciones en paralelo (para .NET):<br /></p><p><span style='font-family:Courier New; font-size:10pt'><span style='color:blue; background-color:white'><strong>using</strong></span><span style='color:black; background-color:white'> Zoe</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>DotNET</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>Utils</span><span style='color:navy; background-color:white'><strong>;<br/></strong></span><span style='color:green; background-color:white'>// Uso el Main de consola por defecto para .NET, si gusta puede usar el Main tradicional :-)<br/></span><span style='color:black; background-color:white'>Zoe</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>ConsoleProgram</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>New</span><span style='color:navy; background-color:white'><strong>{<br/></strong></span><span style='color:black; background-color:white'> </span><span style='color:green; background-color:white'>// Diga Hola!!<br/></span><span style='color:black; background-color:white'> Console</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>WriteLine</span><span style='color:navy; background-color:white'><strong>(</strong></span><span style='color:gray; background-color:white'>"Welcome to new semantic structures with LayerD !!"</span><span style='color:navy; background-color:white'><strong>);<br/></strong></span><span style='color:black; background-color:white'> </span><span style='color:green; background-color:white'>//Ejecutar instrucciones en hilos separados<br/></span><span style='color:black; background-color:white'> Concurrent</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>ExecuteParallel</span><span style='color:navy; background-color:white'><strong>{<br/></strong></span><span style='color:black; background-color:white'> </span><span style='color:green; background-color:white'>//En un hilo cuento cosas<br/></span><span style='color:black; background-color:white'> </span><strong><span style='color:blue; background-color:white'>for</span><span style='color:navy; background-color:white'>(</span></strong><span style='color:#8000ff; background-color:white'>int</span><span style='color:black; background-color:white'> n</span><span style='color:navy; background-color:white'><strong>=</strong></span><span style='color:#ff8000; background-color:white'>0</span><span style='color:navy; background-color:white'><strong>;</strong></span><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong><</strong></span><span style='color:#ff8000; background-color:white'>40000001</span><span style='color:navy; background-color:white'><strong>;</strong></span><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong>++)<br/></strong></span><span style='color:black; background-color:white'> </span><strong><span style='color:blue; background-color:white'>if</span><span style='color:navy; background-color:white'>(</span></strong><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong>%</strong></span><span style='color:#ff8000; background-color:white'>20000000</span><span style='color:navy; background-color:white'><strong>==</strong></span><span style='color:#ff8000; background-color:white'>0</span><span style='color:navy; background-color:white'><strong>)</strong></span><span style='color:black; background-color:white'>Console</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>WriteLine</span><span style='color:navy; background-color:white'><strong>(</strong></span><span style='color:gray; background-color:white'>"I am on "</span><span style='color:navy; background-color:white'><strong>+</strong></span><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong>+</strong></span><span style='color:gray; background-color:white'>"."</span><span style='color:navy; background-color:white'><strong>);<br/></strong></span><span style='color:black; background-color:white'> </span><span style='color:green; background-color:white'>//En otro hilo cuento dos cosas :-)<br/></span><span style='color:black; background-color:white'> </span><span style='color:navy; background-color:white'><strong>{<br/></strong></span><span style='color:black; background-color:white'> </span><strong><span style='color:blue; background-color:white'>for</span><span style='color:navy; background-color:white'>(</span></strong><span style='color:#8000ff; background-color:white'>int</span><span style='color:black; background-color:white'> n</span><span style='color:navy; background-color:white'><strong>=</strong></span><span style='color:#ff8000; background-color:white'>0</span><span style='color:navy; background-color:white'><strong>;</strong></span><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong><</strong></span><span style='color:#ff8000; background-color:white'>40000001</span><span style='color:navy; background-color:white'><strong>;</strong></span><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong>++)<br/></strong></span><span style='color:black; background-color:white'> </span><strong><span style='color:blue; background-color:white'>if</span><span style='color:navy; background-color:white'>(</span></strong><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong>%</strong></span><span style='color:#ff8000; background-color:white'>2000000</span><span style='color:navy; background-color:white'><strong>==</strong></span><span style='color:#ff8000; background-color:white'>0</span><span style='color:navy; background-color:white'><strong>)</strong></span><span style='color:black; background-color:white'>Console</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>WriteLine</span><span style='color:navy; background-color:white'><strong>(</strong></span><span style='color:gray; background-color:white'>"You are on "</span><span style='color:navy; background-color:white'><strong>+</strong></span><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong>+</strong></span><span style='color:gray; background-color:white'>"."</span><span style='color:navy; background-color:white'><strong>);<br/></strong></span><span style='color:black; background-color:white'> </span><strong><span style='color:blue; background-color:white'>for</span><span style='color:navy; background-color:white'>(</span></strong><span style='color:#8000ff; background-color:white'>int</span><span style='color:black; background-color:white'> n</span><span style='color:navy; background-color:white'><strong>=</strong></span><span style='color:#ff8000; background-color:white'>0</span><span style='color:navy; background-color:white'><strong>;</strong></span><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong><</strong></span><span style='color:#ff8000; background-color:white'>40000001</span><span style='color:navy; background-color:white'><strong>;</strong></span><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong>++)<br/></strong></span><span style='color:black; background-color:white'> </span><strong><span style='color:blue; background-color:white'>if</span><span style='color:navy; background-color:white'>(</span></strong><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong>%</strong></span><span style='color:#ff8000; background-color:white'>2000000</span><span style='color:navy; background-color:white'><strong>==</strong></span><span style='color:#ff8000; background-color:white'>0</span><span style='color:navy; background-color:white'><strong>){<br/></strong></span><span style='color:black; background-color:white'> Console</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>WriteLine</span><span style='color:navy; background-color:white'><strong>(</strong></span><span style='color:gray; background-color:white'>"We are on "</span><span style='color:navy; background-color:white'><strong>+</strong></span><span style='color:black; background-color:white'>n</span><span style='color:navy; background-color:white'><strong>+</strong></span><span style='color:gray; background-color:white'>"."</span><span style='color:navy; background-color:white'><strong>);<br/></strong></span><span style='color:black; background-color:white'> </span><span style='color:navy; background-color:white'><strong>}<br/></strong></span><span style='color:black; background-color:white'> </span><span style='color:navy; background-color:white'><strong>}<br/></strong></span><span style='color:black; background-color:white'> </span><span style='color:navy; background-color:white'><strong>};<br/></strong></span><span style='color:black; background-color:white'> Console</span><span style='color:navy; background-color:white'><strong>::</strong></span><span style='color:black; background-color:white'>Read</span><span style='color:navy; background-color:white'><strong>();<br/></strong></span><span style='color:black; background-color:white'> </span><span style='color:green; background-color:white'>// Fin<br/></span><span style='color:navy'><strong><span style='background-color:white'>};</span><br /> </strong></span></span></p><p>El ejemplo superior ejecutara cada instrucción dentro del bloque "Concurrent::ExecuteParallel" en un hilo diferente.<br /></p><p>Este ejemplo sólo corre en .NET porque esta implementado usando sólo la librería de dicho entorno de ejecución. La buena noticia es que junto a mi amigo (el Ingeniero) Pablo Frias vamos a estar desarrollando en los próximos meses una librería para programación concurrente en LayerD que sea además multiplataforma (al menos Java y .NET) e incluya estructuras de "alto nivel" como tareas, ciclos paralelos, etc.<br /></p><p>Pueden ver este ejemplo en el SDK, el cliente y la classfactory. Saludos. </p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-2298227014265863842008-07-22T22:58:00.002-03:002008-07-24T15:19:51.714-03:00Primer Upload de Código Fuente<span xmlns=""><p>Como se prometió con anterioridad empecé a subir el código fuente del proyecto LayerD para que esté disponible bajo licencias Open Source.<br /></p><p>Los links a SourceForge:<br /></p><ul><li><a href="http://sourceforge.net/forum/forum.php?forum_id=848956">http://sourceforge.net/forum/forum.php?forum_id=848956</a><br /> </li><li><a href="http://sourceforge.net/projects/layerd">http://sourceforge.net/projects/layerd</a><br /> </li></ul><p>En el primer upload de código subí los siguientes componentes:<br /></p><ul><li>Compilador Meta D++<br /></li><li>Zoe CodeDOM para C++ y C#<br /></li><li>Modulo de Salida Zoe para .NET<br /></li><li>Modulo de Salida Zoe para Meta D++ (para compilación interactiva)<br /></li><li>Generador de CodeDOM para C++ y C# (utilidad que genera las clases del CodeDOM a partir del esquema del lenguaje Zoe en XSD)<br /></li><li>Una librería común usada por los módulos de salida Zoe y el compilador Zoe (cuando estos son programados para en .NET)<br /></li></ul><p>Para todos estos componentes utilice la licencia BSD, licencia que otorga enorme flexibilidad ;-).<br /></p><p>Cuando revise un poco el código del compilador Zoe lo subo al repositorio de SourceForge, esta porción de código pienso usar licencia Eclipse o Mozilla (un poco más "restrictiva" que la BSD). El código de los modulos subidos varía en calidad ya que fue desarrollado durante diversas etapas :-), un poco a la apurada, un poco bien, un poco "temporal".<br /></p><p>Bueno, los post están pobres últimamente, pero estoy preparando cosas interesantes y aplicaciones prácticas reales como software que corre en .NET escritorio, ASP.NET y J2EE sin cambios. Tampoco me he olvidado de la documentación que también la estoy revisando y actualizando. Por cierto, aparentemente LayerD se usará en una parte de otro proyecto comercial (es decir un proyecto "real" de desarrollo) más adelante les confirmo.<br /></p><p>Por cierto, cualquier consulta sobre el código me consultan, ni hablar si quieren colaborar en algo serán más que bienvenidos ;-)<br /></p><p>Saludos. Alexis.-<br /></p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-91010287708463190612008-06-24T21:07:00.001-03:002008-07-24T15:13:17.754-03:00Inferencia de tipos de variables locales<span xmlns=''><p>Meta D++ (el único lenguaje LayerD de alto nivel funcional hoy por hoy) basa su semántica en una copia exacta del lenguaje intermedio de la plataforma LayerD, el lenguaje Zoe. <br /></p><p>Zoe posee características de orientación a objetos básica como polimorfismo, ocultación y herencia. Sin embargo, algunas características disponibles en otros lenguajes de programación orientados a objetos no se encuentran disponibles nativamente. Por otro lado, Zoe (y por tanto todo lenguaje LayerD de alto nivel como Meta D++) posee un diseño modular y procesamiento programable en "tiempo de compilación". Estas características de Zoe permite programar extensiones para los lenguajes LayerD de alto nivel sin depender de los fabricantes o diseñadores de lenguajes.<br /></p><p>En esta nota mostraré cómo es posible incorporar en Zoe (y por extensión en Meta D++) inferencia de tipos para variables locales. Esta idea es desarrollada en algunos lenguajes como C# a partir de la versión 3.0 y trata simplemente de no requerir duplicar el tipo en una declaración "infiriéndolo" de su inicialización, por ejemplo en lugar de escribir:<br /></p><p><span style='font-family:Courier New; font-size:9pt'>int a = 12;<br/>ArrayList lista = new ArrayList();<br/>MiTipo[] matriz = new MiTipo[4];<br /></span></p><p>En C# a partir de la versión 3.0 se puede escribir lo siguiente:<br /></p><p><span style='font-family:Courier New; font-size:9pt'>var a = 12;<br/>var lista = new ArrayList();<br/>var matriz = new MiTipo[4];<br /></span></p><p>El lenguaje Meta D++ no soporta esta capacidad nativamente que en ocasiones suele ser útil permitiendo escribir unas cuantas letras menos a los programadores y también mejorar la legibilidad del código eliminando la redundancia. Pero ello no es limitación para incorporar la característica en Zoe usando una classfactory y luego poder usarla desde Meta D++.<br /></p><p>El código en Meta D++ para incluir esta capacidad usando una classfactory es el siguiente:<br /></p><p><span style='font-family:Courier New; font-size:9pt'>public factory class var{<br/>public:<br/><br/>//Declaro el constructor de tipo por defecto<br/>type var(){<br/> try{<br/> //Si no es llamado como parte de una <br/> //declaracion de variable local es un error<br/>01 if(context.get_Parent().get_TypeName()!="XplDeclarator")<br/> return new XplType();<br/> //Obtengo la declaración<br/>02 XplDeclarator^ decla = (XplDeclarator^)context.get_Parent();<br/> //Busco la primera expresion de inicialización<br/>03 if(decla.FindNode("/e")!=null){<br/> //Determino el tipo a partir de la expresion de inicialización<br/>04 return ZoeHelper::MakeTypeFromString( ((XplExpression^)decla.FindNode("/e")).get_typeStr() );<br/> }<br/> else{<br/> //Si no posee expresion de inicializacion <br/> //busco la primera asignación<br/>05 XplNode^ temp = context.CurrentBlock.FindNode(<br/> "/a/l/n("+decla.get_name()+")");<br/> if(temp!=null){<br/> //Determino el tipo a partir de la expresion <br/> //derecha de la primera asignación<br/>06 return ZoeHelper::MakeTypeFromString( ((XplAssing^)temp).get_r().get_typeStr() );<br/> }<br/> }<br/> }<br/> catch(Exception^ error){<br/> //Si hubo algun error emito un mensaje y luego genero un error<br/>07 Console::WriteLine(error.Message);<br/> }<br/> //Esto generará un error de compilación<br/>08 return new XplType();<br/>}<br/><br/>}<br /></span></p><p>Efectivamente el código para agregar inferencia de tipos de variables locales lleva apenas 12 líneas de código efectivo en Meta D++. Y permite ser utilizado desde un programa cliente Meta D++, por ejemplo como sigue:<br /></p><p><span style='font-family:Courier New; font-size:9pt'>static int Main(string^[] args){<br/> ArrayList^ test = new ArrayList();<br/> ///Insert code here<br/> var n = "hola";<br/> var matriz = new int[] = {1,2,3,4};<br/> var matriz2 = new App[4];<br/> var matriz3;<br/> matriz3 = new int[10];<br/> var j;<br/> j = 12.4f;<br/> var y;<br/> y = new App();<br/> return 0;<br/>}<br /></span></p><p>El ejemplo de programa cliente inferirá que "n" es de tipo "string^", matriz de tipo "int[]", j de tipo "float", etc.<br /></p><p><strong>¿Cómo funciona la classfactory?<br /></strong></p><p>La classfactory "var" utiliza un tipo de constructores especiales accesibles por classfactorys. Estos constructores se denominan "Constructores de Tipo", específicamente el usado es un "constructor de tipo por defecto" ya que no toma ningún parámetro.<br /></p><p>Los constructores de tipos en classfactorys son llamados cada vez que un programa cliente declara una variable o nombra el tipo de la classfactory, en el caso del ejemplo cada vez que se declara una variable local de tipo "var".<br /></p><p>A continuación explico cada una de las líneas marcadas con números del programa:<br /></p><p>01 – Si no se trata de una declaración de variable local retorno un tipo vacio (usando "new XplType()") lo cual generará un error en el programa cliente, en este caso es lo que deseo.<br/>02 – Obtengo el nodo de declaración, es decir el padre del contexto de llamada al constructor de tipo.<br/>03 – Busco la primera expresión a partir del nodo de declaración, la cual será la expresión de inicialización.<br/>04 – Si encuentro una expresión de inicialización utilizo el tipo de dicha expresión para inferir el tipo de la variable.<br/>05 – Si no encuentro una expresión de inicialización busco una asignación.<br/>06 – Si no encuentro una asignación es un error, emito un tipo vacio para generar el error.<br/>07 – Si ocurre un error inesperado cualquiera capturo la excepción.<br/>08 – Si la ejecución llega a la última línea es un error, retorno un tipo vacio para generar el error.<br /></p><p><strong>Resumen<br /></strong></p><p>Para agregar una nueva funcionalidad, en este caso inferencia de tipo de variables locales, basta con desarrollar una classfactory de una decena de líneas. Luego, la funcionalidad esta disponible en cualquier lenguaje LayerD de alto nivel sin necesitar cambiar ningún compilador o modulo generador de código, simplemente código en el mismo lenguaje que el resto de un programa ordinario LayerD. Por supuesto que no todas las nuevas funciones que querramos agregar a los lenguajes LayerD serán tan fácil de desarrollar, sin embargo, si poseeremos en nuestras manos las herramientas y la libertad para hacerlo cuando creamos que lo necesitamos sin depender de los diseñadores de los lenguajes o los fabricantes de los compiladores.<br /></p><p>El ejemplo sencillo presentado se puede mejorar emitiendo errores usando la interfaz "compiler" o incluso permitir la inferencia de variables locales sin utilizar el tipo "var". Más interesante, toda extensión semántica para el lenguaje, como la presentada, la podemos usar sólo donde lo queremos e incluso combinar funcionalidad.<br /></p><p>Otros tipos de extensiones semánticas que podemos desarrollar para cualquier lenguaje LayerD, por nombrar algunas, incluyen: tipos genéricos, aspectos, tipos anónimos, precondiciones y postcondiciones, tareas, bloques para ejecución en paralelo, bloques for concurrentes para matrices o colecciones, estructuras de sincronización, bloques de recuperación, y un etcétera tan largo como tu propia imaginación y capacidad.</p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-39142717951276766762008-06-09T00:25:00.001-03:002008-07-24T15:13:49.046-03:00Un lenguaje de dominio especifico para interfaces gráficas<span xmlns=''><p>Muchas veces me paso que al desarrollar una aplicación de escritorio no incluí una ventana más para evitar el tedio de tener que abrir el diseñador de ventanas del entorno y genera otro archivo y otra clase más con todo el código generado (que en general es terrible je). Por tanto, para evitarme esa complicación termine reutilizando otra ventana que ya tenía aunque no fuera lo más adecuado.<br /></p><p>Por otro lado, si hemos tenido la oportunidad de programar interfaces gráficas en más de un lenguaje o en más de una API aún en el mismo lenguaje, sabremos que cada quién trabaja las interfaces como quiere. En definitiva una ventana con un textbox y un botón aceptar, es eso. Sin embargo, si lo programamos en C# es de una forma con Windows Form, con WPF es de otra manera, si usamos C++ lo podemos hacer con el API de Windows, con MFC, con GTK o cualquier otra librería, en Java lógicamente es distinto, en Javascript también por supuesto es diferente. En cada plataforma los eventos se enlazan de manera diferente, los contenedores trabajan distinto, entre otros problemas.<br /></p><p>El problema que encara el ejemplo del post, es la complejidad del código y la poca legibilidad. Por ejemplo, si construimos una ventana con C# usando Windows forms debemos de hacer una clase que herede de System.Windows.Forms.Form, luego estableceremos las propiedades en el constructor o en algún otro método. Los controles internos también los deberemos de definir en general como campos, agregarlos al contenedor, setearle las propiedades, capturar los eventos, etc. Todo este código hace que al final tengamos una clase la cual, si no fuera por la ayuda de los IDEs nos sería complicado de manipular y entender.<br /></p><p>En lugar de tener que escribir todo ese código no necesariamente intuitivo para quien no uso antes la librería, en LayerD podemos desarrollar una classfactory que nos permita declarar y utilizar interfaces graficas de la siguiente forma:<br /></p><p><span style='font-family:Courier New; font-size:8pt'>GUI::Window(MiVentana3){<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Text = <span style='color:#a31515'>"Una ventana en un DSL con LayerD"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Controls{<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Button(CSalir){<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Text=<span style='color:#a31515'>"Salir"</span>; AutoSize=<span style='color:blue'>true</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Click{<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> MessageBox::Show(<span style='color:#a31515'>"Saliendo de la aplicación"</span>);<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:blue'>this</span>.Close(); <br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'>};<br /></span></p><p>El código superior casi no necesita explicación si se toma el trabajo de leerlo. Declara una ventana cuyo nombre será "MiVentana3", establece el título de la ventana con "Text = "Una ventana en un DSL con LayerD"". Luego se especifican los controles directamente dentro del bloque "Controls". El ejemplo muestra un botón "CSalir" al cual se capturo el evento "Click" simplemente escribiendo "Click{…}" y proporcionando la implementación del evento entre llaves, las propiedades del botón se establecieron como simples asignaciones "Text = "Salir";" y "AutoSize = true;".<br /></p><p>El lenguaje de dominio específico está pensado de tal forma que es posible utilizar cualquier clase de Windows Forms directamente dentro de la colección de controles, setear propiedades y capturar eventos de forma directa usando sólo el nombre del evento y proporcionando la implementación en un bloque.<br /></p><p>En el SDK de LayerD podrá encontrar un ejemplo de uso de este lenguaje de dominio específico "EjemploGUI.dpp" y la classfactory que implementa el lenguaje de dominio especifico en "Zoe.DotNET.UtilsTemplate.dpp". Puede insertar un ejemplo en su código usando el modo interactivo con la instrucción "<span style='font-family:Courier New; font-size:10pt'>Zoe::DotNET::Utils::iGUI::Help()</span>" (o sólo "<span style='font-family:Courier New; font-size:10pt'>iGUI::Help()</span>" si ya tiene un using "<span style='font-family:Courier New; font-size:10pt'>Zoe::DotNET::Utils</span>").<br /></p><p>Si comparamos el código superior con el código de una ventana en C# o Java es muy probable que le parezca mucho más claro, más fácil de leer y hasta se anime a escribirlo a mano sin la ayuda de un diseñador :-) .<br /></p><p>Por cierto, la classfactory que implementa este lenguaje de dominio específico no tiene miles de líneas de código :-). El ejemplo, encara uno de los problemas de las GUI en muchos de los lenguajes actuales volviendo el código de GUIs fácil de escribir, leer y mantener (lo cual no es necesariamente poco), pero sólo sirve para ser utilizada para desarrollar GUIs para .NET usando Windows Forms. Una mejora de este DSL será agregar la capacidad multiplataforma y permitir que sirva para Windows Forms, WPF, ASP.NET y Java. Ello es perfectamente posible en LayerD, simplemente hay que trabajar un poquito más :-), con seguridad uno de los ejemplos futuros.<br /></p><p>A modo de avance les paso un ejemplo de un GUI similar para hacer paginas ASP.NET en LayerD:<br /></p><p><span style='color:green; font-family:Courier New; font-size:8pt'>///Pagina ASP.NET 2.0 implementada con un DSL<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'>ASPNET::Page(TestPage){<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Title = <span style='color:#a31515'>"La primera pagina ASPNET en un DSL con LayerD"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Controls{<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<html xmlns=\"http://www.w3.org/1999/xhtml\" >"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<head>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<title>Pagina ASP.NET 2.0 implementada con un DSL usando Meta D++.</title>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"</head>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<body>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<h2>El título de mi primera pagina ASP.NET en LayerD</h2>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<br/>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> HtmlForm(form1){<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Controls{<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Label(l2){<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> CssClass=<span style='color:#a31515'>"miClaseCSS"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Text=<span style='color:#a31515'>"Label Inicio"</span>; <br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<br/>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Calendar(c1){<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> ID=<span style='color:#a31515'>"c1"</span>; <br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<br/>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Button(CSalir){<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Text=<span style='color:#a31515'>"¡Hacer Algo!"</span>; <br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Click{<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> l2.Text=<span style='color:#a31515'>"Hola Mundo desde el Server"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<br/>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"<br/>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Button(CCambiar){<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Text=<span style='color:#a31515'>"Cambiar página"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Click{<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> Response.Redirect(<span style='color:#a31515'>"testajax.aspx"</span>);<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"</body>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> <span style='color:#a31515'>"</html>"</span>;<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'> };<br /></span></p><p><span style='font-family:Courier New; font-size:8pt'>};<br /></span></p><p><span style='color:green; font-family:Courier New'><span style='font-size:8pt'>///Fin Pagina ASP.NET 2.0 implementada con un DSL</span><span style='font-size:10pt'><br /> </span></span></p><p>Hasta la próxima!!</p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-30414727310851254132008-06-08T23:58:00.001-03:002008-07-24T15:15:14.595-03:00Mis colegas me deprimen versión 2.0<span xmlns=''><p>En un post anterior comentaba como "Mis colegas me deprimen" y hablaba de la poca "ingeniería" que a mi parecer enseñan aún excelentes profesores y como muchas de las "tecnologías" propuestas por las grandes empresas son "patéticas". A varias personas les pareció muy crítico, por tanto aprovecho a explicarme un poco mejor.<br /></p><p>No voy a negar que muchas veces "mis colegas me deprimen" porque ello es verdad, lo que sí creo es necesario aclarar a que me refiero. La conclusión a la que llego al final del post anterior es que en realidad el problema está en nuestra profesión, en la ingeniería de software y no en los profesionales, por tanto concluyo que lo que me deprime es el estado del arte en la ingeniería de software y por extensión me "deprimen" mis colegas aún muchos de los más brillantes y admirables.<br /></p><p>La ingeniería de software me parece precaria y deprimente por las siguientes razones:<br /></p><ul><li>El software es una abstracción, sin embargo nos pasamos la vida reescribiendo aplicaciones todo para que corran en diferentes runtimes o con diverso middleware.<br /></li><li>El software que escribimos rara vez dura más de diez años.<br /></li><li>El software no puede arreglarse a sí mismo.<br /></li><li>Para escribir una aplicación web debo conocer y utilizar al menos tres lenguajes diferentes, todo porque los lenguajes actuales están acoplados a un runtime en particular y no son modulares.<br /></li><li>Puedo diseñar una arquitectura muy buena para mi software, pero al implementarla dependeré de middleware y runtimes los cuales limitarán el tiempo de vida de mi aplicación.<br /></li><li>Todavía seguimos aprendiendo todos los años (cada vez que un nuevo fabricante renueva una librería o lenguaje) a realizar lo mismo una y otra vez sin aprender nada realmente nuevo.<br /></li><li>Las librerías de software que usamos son pasivas, no nos advierten si las usamos mal, tampoco nos enseñan a utilizarlas o de conflictos entre ellas.<br /></li><li>Seguimos escribiendo la gran parte del software de forma artesanal.<br /></li><li>Una línea de código sigue siendo capaz de colgar el más complejo de los sistemas en la mayoría de los sistemas.<br /></li><li>Cada vez que necesitamos trabajar con un nuevo paradigma debemos de usar nuevos lenguajes y herramientas (en los próximos inmediatos años veremos como los lenguajes "main-stream" empiezan a "mutar" para incluir características que faciliten la programación concurrente).<br /></li><li>Estamos obligados a usar una sintaxis en particular para beneficiarnos de lo único importante en un lenguaje que es su "semántica" y lo que es peor, estamos obligados a usar esa misma sintaxis para leer y analizar los programas.<br /></li><li>El código fuente no puede analizarse a sí mismo en el común de los lenguajes de programación.<br /></li><li>Quienes investigan e impulsan la "ingeniería de software" (hablando de metodologías, arquitectura, etc.) cada vez más se separan en sus estudios de los lenguajes y herramientas de implementación, lo cual humildemente me parece errado.<br /></li></ul><p>Mi objetivo, no es criticar profesionales, universidades o empresas. El medio es criticarlas, el objetivo es despertar a quienes son jóvenes y hacerles ver que nuestra profesión es primitiva y debemos de contribuir mucho para que algún día podamos estar orgullosos de estar en la industria del software. Creer que hoy día el software es avanzado, que los profesionales de software construimos obras de ingeniería memorables, es en términos generales una mentira a nosotros mismos. LayerD es mi propuesta para encarar muchos de estos problemas, no le quepa duda que no los solucionará a todos, pero humildemente creo que se trata de encarar la realidad con opciones un poco diferentes, al final entre todos o alguna mente brillante encontraremos una solución para estos problemas.<br /></p><p>Si hay algo que me cautivo desde siempre del software, es que las posibilidades son cercanas al infinito. No creo que sea posible decir hasta donde se llegará, lo que estoy seguro es que en algún momento en el futuro las generaciones que vendrán mirarán hacia atrás y observarán un panorama primitivo, frágil, vacio, oscuro, pero también encontraran gente que con pasión y trabajo empujo un poquito y en suma a lo largo de las generaciones se logro llegar a algo realmente memorable.</p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-79923515845149476552008-05-20T00:51:00.007-03:002008-07-24T15:15:00.668-03:00Deja Vu<span xmlns="">No es la primera vez que tengo esta sensación de haber vivido una y otra vez la misma situación con el desarrollo de software.<br /><div><div><br /><p>Observen la siguiente pantalla:<br /></p><br /><img id="BLOGGER_PHOTO_ID_5202303767542526098" style="DISPLAY: block; MARGIN: 0px auto 10px; CURSOR: hand; TEXT-ALIGN: center" alt="" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiKA1iNJ3fJYNCa1skBGrSa77ZjTNti3oIe9XewjswDCVBhGc9hOr1cSmtZIc_GEsbEyuSh9J-eCZ2o7LwxaKukr-V6ZZ0XJDxb9FF-7Qi7MRBMBIweApTlqyv4OBvqJPwM_niHOOQwiyOO/s320/Dibujo1.jpg" border="0" /><br /><p>La imagen superior muestra uno de los tantos procesadores de texto en línea que han surgido últimamente. </p><p>Ahora vean la siguiente imagen:<br /></p><br /><img id="BLOGGER_PHOTO_ID_5202303922161348770" style="DISPLAY: block; MARGIN: 0px auto 10px; CURSOR: hand; TEXT-ALIGN: center" alt="" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEjUC84u7ZUPLlcouRzGrST_7Jx_xhFvrdES9boIPPjF8i8CYuodwmZOdmh-U-8n6CJifWwXM9NH2qR2-edy9ANIjZHxeFbPjUTifAkXXknoPsHKGWAQA_O1W8v894Ic9H1sI13yBAbthdwm/s320/Dibujo2.jpg" border="0" /><br /><p>Muestra una "ventana" para la configuración de la página en dicho procesador de texto en línea.<br /></p><br /><p>Tenemos dos formas de analizar esta pieza de software, por cierto muchos pensarían que es una excelente obra de ingeniería de software. En la imagen no se puede apreciar, pero el procesador de texto en realidad posee un completo sistema de manejo de ventanas incluyendo arrastre, redimensión en algunos casos, lógica de foco de controles, una multitud de controles de usuario "AJAX" como tabs, combos, barras de herramientas, paneles ocultables, etc.<br /></p><br /><p>Si analizamos todo el trabajo que lleva desarrollar una aplicación de este tipo no nos queda más que pensar que estamos en presencia de una buena pieza de software.<br /></p><br /><p>Por otro lado, al entrar a dicho procesador de texto en línea, tuve múltiples deja vu simultáneos. Me recordaron cuando implemente un patético sistema de "ventanas" (no móviles por cierto) en QuickBasic usando caracteres en la consola de DOS de 80x25 caracteres ASCII <span style="font-family:Wingdings;">J</span>. Me recordó cuando implemente otro rudimentario sistema de ventana para otra aplicación DOS esta vez en modo grafico usando VGA de 320x200 pixeles a 256! colores simultáneos para un programa de diseño vectorial también en QuickBasic y como cambiaba la paleta de colores usando la INT 10 si mal no recuerdo o capturar las coordenadas del mouse usando los registros AX BX CX y DX por medio la un tanto odiada por mi interrupción 33 (solía no cargar el controlador del mouse en autoexec.bat). También me acorde de otro mini sistema de ventanas hecho ya en una mezcla de C++ y C (nunca olvidare cuando descubrí los punteros a función <span style="font-family:Wingdings;">J</span> que bendición!!!) en el modo VGA de 640x480 y 16 colores, esta vez con ventanas móviles y redimensionables, captura de algunos eventos y unas primitivas para dibujar cubos en 3D en perspectivas ortogonal y logarítmica (perdón por tantos recuerdos :-P). Y al acordarme de todo eso pensé "cuando construí esos primitivos sistemas de ventanas era un adolescente que jugaba programando, sabía nada de ingeniería de software (y no porque piense que ahora se mucho)".<br /></p><p>Al ver otro procesador de texto "re-implementado" para la web se me vinieron a la mente multitud de procesadores de texto, sistemas de ventanas, IDEs, planillas de cálculo, juegos, todos re-escritos infinidad de veces hasta el cansancio en diferentes sistemas operativos, entornos de ejecución y plataformas de hardware. </p><p><br />La verdad es que aplicaciones como éste procesador de texto le pueden parecer muy lindas y desarrolladas aplicaciones a los desarrolladores más jóvenes, pero a mí, sólo me recuerdan el estado del arte en la ingeniería de software. Me recuerdan que no somos capaces de reutilizar seriamente ningún desarrollo importante más allá del tiempo de vida de la plataforma de desarrollo original de la aplicación. Me recuerda lo primitivos que somos y cuanto tenemos para crecer en software. Lo cierto es que este tipo de aplicaciones cuando surgen una y otra vez (últimamente los celulares y la web se llevan todos los premios a la reescritura de viejas aplicaciones en nuevos runtimes) no hacen más que mostrarnos que mucho no hemos avanzado como ingenieros<span style="font-family:Wingdings;">J</span>, o al menos eso me parece.<br /></p><br /><p>Si el software es algo abstracto, y un procesador de texto es un procesador de texto se ejecute en DOS, Windows, Linux o en un servidor Web o en un explorador, porque debemos de reescribirlo una y otra vez cada vez que surge un nuevo entorno de ejecución o una nueva serie de librerías de base??<br /></p><br /><p>La verdad es que ello no es necesario, simplemente aparentemente a poca gente le preocupa el tema (sobre todo a las grandes empresas proveedoras de software de base parece no importarles jeje), a mi me parece inaceptable si queremos llamarnos verdaderos ingenieros alguna vez en la vida.<br /></p><br /><p>En los próximos post "productivos" espero poder empezar a mostrar como con LayerD es posible encarar esta limitación en la ingeniería de software actual y resolver el problema del acoplamiento del software con un API en particular o un entorno de tiempo de ejecución. Con suerte, podré demostrar que el acoplamiento entre software implementado+API+runtime no es necesario y es posible desarrollar software abstracto que siempre posea medios automatizados para ser adaptado a nuevos entornos de tiempo de ejecución o APIs que surjan en el futuro. Así quizás en un futuro no vuelva a tener todos estos deja vu y deje de considerar a nuestra profesión precaria.<br /></p></span></div></div>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-46220279564917050012008-05-18T23:31:00.001-03:002008-07-24T15:15:25.404-03:00Sobre la palabra “Classfactory” y Mis “colegas” me deprimen<span xmlns=''><h4>Sobre la palabra "Classfactory" y "Classfactorys"<br /></h4><p>Aclaraciones importantes detrás de la palabra classfactory y su plural:<br /></p><ul><li>El singular, es decir si hablamos de una sola clase es "classfactory"<br /></li><li>El plural, es decir si hablamos de más de una clase es "classfactorys" y esta bien escrito!! no es "classfactories".<br /></li></ul><p>¿Por qué se llaman de esa forma?<br /></p><ul><li>Porque necesitaba un nombre para diferenciar clases "normales" de tiempo de ejecución de clases "de tiempo de compilación". Como normalmente una clase de tiempo de compilación se utilizará para "fabricar código" decidí llamarlas "clases fabricas". Una "clase fabrica" en ingles seria una "factory class" y "clases fabrica" seria "factory classes" (si es que merezco haber aprobado algún curso de inglés básico). Por tanto, decidí llamarla "classfactory" en singular – aquí la humorada es usar palabras en ingles pero orden de sustantivo/adjetivo en español, y usar el plural "classfactorys" porque el singular es "classfactory" que como es una palabra cualquiera inventada para describir una clase de tiempo de compilación, su plural en castellano lo formo agregando una "s" como normalmente haríamos quienes hablamos español, por tanto el plural es "classfactorys" y NO "classfactories". <br /></li></ul><p>Si a alguien no le gusta el plural o incluso el singular, está bien, pero sinceramente no me importa es sólo una palabra <span style='font-family:Wingdings'>J</span>.<br /></p><h4>Mis "colegas" me deprimen<br /></h4><p>Tal vez soy una persona con demasiado ego, tal vez creo que se demasiado o que soy capaz de ver más que la mayoría – siempre hablando de lo profesional no <span style='font-family:Wingdings'>J</span>. Realmente, me pregunto si es que aunque no me guste soy un profesional tan engreído y tonto. A veces me da miedo pensar las cosas que pienso de algunos "colegas" que tienen muchísima más experiencia, años y conocimientos de los que yo tengo.<br /></p><p>Veo muchos profesores muy respetados de mi facultad, profesionales que trabajan en grandes y reconocidas empresas, todas personas que tienen algunos años más que yo y otros muchos más años <span style='font-family:Wingdings'>J</span>, pero la mayoría saben más de algoritmos, de matemáticas, de bases de datos, o de lo que fuera, de lo que yo sé. Todos ellos tienen mucha más experiencia medida en cantidad de trabajos y años de la que poseo.<br /></p><p>Sin embargo, no puedo evitar ver los errores que cometen, y pensar "que limitada visión". Me preocupa pensar que todos los profesores que tuve en mi facultad – que no es cualquier facultad – en realidad saben muy poco de ingeniería de software o al menos no lo enseñan. Me preocupa pensar que no son capaces de ver más allá de sus narices y enseñarles a sus alumnos ingeniería de verdad. Me preocupa creer que no tienen la formación ni la visión necesaria para enseñarles a sus alumnos a ser verdaderos ingenieros, para enseñarles a ver con profundidad, para ser críticos. Sinceramente espero equivocarme y que todo ello sólo sea estúpida vanidad mía.<br /></p><p>Me preocupa pensar que casi todas las nuevas "tecnologías" de desarrollo que proponen grandes empresas como SUN o Microsoft son deprimentes, patéticas. Después de todo, estas grandes empresas contratan a las personas más "brillantes" para construir lo que nos venden, pero a pesar de ese pensamiento o a causa de ello, me parecen aún más deprimentes.<br /></p><p>La verdad, es que la visión que tengo de todos estos profesionales - que el resto de las personas consideran excelentes - personalmente me deprime, me deprime pensar que los profesionales más excelentes que conozco no tienen capacidad visionaria, me deprime ver como los mejores profesores de mi facultad enseñan a construir - lo que para mí son meramente chozas a lo sumo con toque de "sofisticación" - a sus alumnos. <br /></p><p>Me da miedo tener tanta vanidad y creer que puedo ver cosas que estos profesionales considerados por todo el mundo excelentes no pueden ver o por lo menos no parecen ver.<br /></p><p>Me alivia ver que muchas personas jóvenes que conozco tienen el potencial para cambiar eso y me gusta pensar que cuando todos estos jóvenes sean la mayoría estaré orgulloso de la ingeniería de software, de mi profesión, de mi vocación. Porque la verdad, hoy el estado del arte y la ingeniería me deprime. Y quizás es eso lo que me deprime y no los profesionales quienes son sólo el producto de una profesión poco desarrollada donde todo está por descubrirse.<br /></p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-80707249289879199712008-05-18T22:50:00.001-03:002008-07-24T15:11:53.695-03:00Dentro de LayerD<span xmlns=''><p>Estos días – y para no perder la costumbre – ando muy escaso de tiempo o energías suficientes como para dormir cuatro horas por día :-P. Por tanto, el post será corto cosa que – créanme – no es una de mis características tener capacidad de resumen para bien o para mal.<br /></p><p>En el <a href='http://layerd.net/blog/Presentacion_1_UTN_2007.pps'>link</a> posteo un PowerPoint que presentamos el año pasado en la UTN-FRC cuando realizamos la primera presentación en sociedad de LayerD (aún sin permitir al público tocar ni siquiera los binarios jeje).<br /></p><p>Fueron muy poquitas personas a la presentación lo cual es de esperar teniendo un título para la charla que no es "muy comercial" y la mala difusión que tuvo. Lo importante del PPT que posteo es que habla de muchas cosas las cuales no están documentadas en otro lado – al menos en la web y que recuerde :-P – y si bien sin su "speech" relacionado no todo se entenderá o tendrá sentido, imagino que puede ser útil para comprender la tecnología LayerD.<br /></p><p>Recuerdo que dicha charla se había planeado como de una hora y media con un recreíto a la mitad, lo cierto es que fueron tan pocas personas que no queríamos que corrieran en el recreo <span style='font-family:Wingdings'>J</span> y además en ese momento ni lo pensé y seguí hablando sin parar y luego mis compañeros Demian, Lucas y Alejandro. Fue bueno ver que casi nadie se fue antes de terminar – tal vez no se fueron para no dejarnos solos <span style='font-family:Wingdings'>J</span> – a pesar de que hablamos largo rato.<br /></p><p>En la charla presentamos varios ejemplos funcionando incluyendo un programa multiplataforma de manejo de archivos que corría sin cambios en Java y NET, una librería activa para conexiones a bases de datos usando ADO.NET, lenguajes de dominio especifico para interfaces gráficas, una estructura para ejecutar fácilmente instrucciones de código en hilos separados, un par de ejemplos en Argentino! (lenguaje LayerD que en este momento se encuentra abandonado lamentablemente), ejemplos de refactoring de código usando classfactorys interactivas, un programa que se corregía a sí mismo si tratábamos de llamar a miembros inexistentes de clases por cometer errores de esctitura, entre otros.<br /></p><p>El PPT habla un poco los modulos de salida, de la clasificación de los modulos de salida, de las características principales del lenguaje Zoe y Meta D++, el proceso de compilación de un programa Zoe, los tiempos de compilación. Más importante quizás es que intenta explicar porque necesitamos poder construir software abstracto.<br /></p><p>LayerD no es un proyecto pensado o construido a la ligera, no es un lenguaje de programación más, o un generador de código o una utilidad para el programador. Muchas cosas se han tenido en cuenta y se han debido de solucionar para poder hoy empezar a tenerlo funcionando, en cuanto se posean los compiladores y módulos de salida desarrollados al nivel adecuado podrá construirse cualquier tipo de software desde un sistema operativo hasta un blog <span style='font-family:Wingdings'>J</span>, con los compiladores y módulos de salida actuales puede desarrollarse cualquier aplicación .NET <span style='font-family:Wingdings'>J</span> y prontamente Java. Lamentablemente, tengo tan poco tiempo de documentar el proyecto que todos los días me veo superado. Por otro lado, de a poco la falta de documentación va mejorando, ya tengo prácticamente un manual básico de Meta D++ que apenas tenga tiempo de revisar publicare, también estoy trabajando en actualizar la Especificación más formal de Meta D++ (que implícitamente especifica Zoe) y los viejos tutoriales del sitio web. Me alienta saber que si estuvo bien pensado, LayerD debe de resistir el paso del tiempo y lo peor que puede pasar es que alguien más lo reinvente uniendo todas las piezas que une LayerD y quizás realice un mejor trabajo y nos beneficiemos todos.<br /></p><p>Quiero cerrar este post tratando de graficar todo lo que LayerD significa y con pocas palabras. Sé que eso es casi imposible porque el proyecto es una visión a mediano y largo plazo para la ingeniería de software, encarnada en herramientas sí, pero no se trata tanto sobre las herramientas sino en cuestionar técnicas, herramientas y formas de solucionar los problemas en la implementación de software. He aprendido que no es sencillo mostrar porque hace falta avanzar en software abstracto, porque LayerD es un camino para llegar a ese objetivo – claro espero no el único – y porque debemos de invertir en ello. Con un poco de suerte y trabajo, espero que en los próximos años quien no use una tecnología similar a LayerD al producir software tenga una gran desventaja competitiva en relación a quienes si lo utilicen y entonces, cuando alguien más visionario lo haya demostrado, el resto comprenderá que no es posible moverse en un mundo de cuatro dimensiones teniendo en cuenta sólo tres o al menos no es posible llegar a todos lados <span style='font-family:Wingdings'>J</span>.<br /></p><p>Aquí va el <a href='http://layerd.net/blog/Presentacion_1_UTN_2007.pps'>link al PPT</a>.<br /></p></span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-85201573790100704802008-05-09T22:37:00.008-03:002008-07-24T15:13:31.684-03:00Inferencia de Esqueleto de Clases a partir de una Rutina Cliente de EjemploLos binarios de LayerD ya estan disponibles para todo el mundo, por tanto comienzo a postear algunos ejemplos. El presente ejemplo es una classfactory un tanto avanzada ya que utiliza varias funciones del CodeDOM de LayerD. Sin embargo, muestra como con classfactorys relativamente simples es posible implementar herramientas que programarlas en IDEs nos llevarían con seguridad bastante más tiempo y sólo nos servirían para ese IDE y lenguaje en particular.<br /><br />Para probar éste ejemplo baje la última actualización del <a href="http://sourceforge.net/project/showfiles.php?group_id=212165">SDK de LayerD desde SourceForge</a>. El SDK de las semanas anteriores no funcionará.<br /><br />Los fuentes para la classfactory y el cliente de ejemplo los puede bajar <a href="http://layerd.net/blog/LayerD_blog_05_11_2008.zip">aquí</a>.<br /><br />Muchas metodologías de programación promueven la escritura en primer lugar de los tests y luego la implementación de las clases y demás artefactos. Entre estas metodologías encontramos las denominadas "Test Driven Development" - Desarrollo Guiado por Pruebas - y los métodos "Agile Programming" - Programación Agíl, o métodos ágiles -.<br />Muchas otras veces en la medida que utilizamos una clase que nosotros escribimos nos damos cuenta que nos faltaron definir métodos, propiedades, etc.<br /><br />Si bien, muchos entornos integrados - IDEs - poseen herramientas que permiten escribir la estructura de por ejemplo métodos inexistentes su funcionamiento no siempre es completo o se adecua a lo que necesitamos. Por ejemplo, en Visual Studio 2005 y 2008 podemos pedirle al entorno que escriba el prototipo de un método por nosotros, sin embargo debemos realizar una serie de clics o controles de tecla por cada método faltante, adicionalmente no permite inferir otras construcciones faltantes en clases como propiedades o indexadores.<br />Por tanto, dependiendo del entorno que poseamos y las capacidades "RAD" de dicho IDE tendremos o no hasta cierto punto la funcionalidad necesaria para encarar de una manera productiva este tipo de enfoque "Guiado por Pruebas".<br /><br />El ejemplo de classfactory interactiva siguiente permite dado un ejemplo de uso inferir gran parte de la estructura pública de una clase incluyendo métodos y propiedades.<br /><br />Una parte del código de la classfactory interactiva es el siguiente<br /><br /><style type="text/css"><br />.csharpcode, .csharpcode pre<br />{<br /> font-size: small;<br /> color: black;<br /> font-family: Consolas, "Courier New", Courier, Monospace;<br /> background-color: #ffffff;<br /> /*white-space: pre;*/<br />}<br /><br />.csharpcode pre { margin: 0em; }<br /><br />.csharpcode .rem { color: #008000; }<br /><br />.csharpcode .kwrd { color: #0000ff; }<br /><br />.csharpcode .str { color: #006080; }<br /><br />.csharpcode .op { color: #0000c0; }<br /><br />.csharpcode .preproc { color: #cc6633; }<br /><br />.csharpcode .asp { background-color: #ffff00; }<br /><br />.csharpcode .html { color: #800000; }<br /><br />.csharpcode .attr { color: #ff0000; }<br /><br />.csharpcode .alt <br />{<br /> background-color: #f4f4f4;<br /> width: 100%;<br /> margin: 0em;<br />}<br /><br />.csharpcode .lnum { color: #606060; }<br /></style><br /><pre class="csharpcode"><br /><span class="kwrd">public</span> interactive <span class="kwrd">class</span> TypeFromSample{<br /><span class="kwrd">public</span>:<br /><span class="kwrd">static</span> exp <span class="kwrd">void</span> New(iname <span class="kwrd">void</span> className){<br />XplClass^ clase = <span class="kwrd">null</span>;<br /><span class="rem">// Search if provided className exists on current namespace</span><br /><span class="rem">// If class doesn't exists create one, insert on current namespace and return a new call</span><br /><span class="rem">// to current function</span><br />clase = (XplClass^)context.CurrentNamespace.FindNode(<span class="str">"/Class[name='"</span> + className.Identifier + <span class="str">"']"</span>);<br /><span class="kwrd">if</span> (clase == <span class="kwrd">null</span>){<br /> clase = writecode{<br /> <span class="kwrd">public</span> <span class="kwrd">class</span> $className{<br /> }<br /> };<br /> <span class="rem">// Insert the class on current namespace</span><br /> context.CurrentNamespace.Children().InsertAtEnd(clase);<br /> <span class="rem">// Return a call to this function with same parameter</span><br /> <span class="kwrd">return</span> writecode( TypeFromSample::New($className) );<br />}<br /><span class="rem">// Search for al missing members in current function, find member access binary operator expressions</span><br />XplNodeList^ items = context.CurrentFunction.FindNodes(<span class="str">"/bo[targetMember='?']"</span>);<br /><span class="rem">// For each missing member try to infer it.</span><br /><span class="kwrd">for</span> (XplBinaryoperator^ op <span class="kwrd">in</span> items){<br /> <span class="kwrd">if</span> (op.get_targetClass().Contains(className.Identifier)){<br /> <span class="rem">// Insert the inferred member on target class</span><br /> clase.Children().InsertAtEnd(CreateFunctionFor(op));<br /> }<br />}<br /><span class="rem">// Return</span><br /><span class="kwrd">return</span> <span class="kwrd">null</span>;<br />}<br />...<br /></pre><br />El método principal es "New" el cual es estático y toma como argumento un "iname", los "inames" permiten tomar como argumento de funciones identificadores, en este caso cualquier identificador incluyendo un identificador no declarado (esto es por ser un "iname void") y retorna una expresión cualquiera.<br />Lo primero que se realiza es verificar si existe en el espacio de nombres actual una clase con el nombre indicado en el argumento, si no existe inyecta una nueva clase con dicho nombre y retorna una llamada al mismo método con el fin de que el compilador Zoe vuelva a realizar otro ciclo de compilación y al ejecutarse nuevamente la función "New" se posea información semántica parcial sobre la manera en la que el programador intento usar al tipo que queremos inferir su estructura.<br />Si la clase indicada como argumento ya existe el método procede a buscar todos los accesos a miembros no resueltos, y luego procesa de dichos elementos sólo los que se correspondan con un acceso al tipo de la clase indicada y los procesa uno por uno con la ayuda de la función "CreateFunctionFor".<br />La función "CreateFunctionFor" de la classfactory utiliza la información de los nodos del CodeDOM para determinar si la expresión padre del acceso a miembro se trata de una llamada a función o de una asignación. Si la expresión padre es una llamada a función infiere los parámetros y tipo de retorno de la función, si es una asignación infiere una propiedad para la clase.<br /><br />Si el programa cliente de la classfactory es el siguiente:<br /><pre class="csharpcode"><br /><span class="kwrd">static</span> <span class="kwrd">int</span> Main(<span class="kwrd">string</span>^[] args){<br /><br /> <span class="rem">// Llamanda a Classfactory Interactiva </span><br /> <span class="rem">// para crear el prototipo de una clase a</span><br /> <span class="rem">// partir de un ejemplo de uso</span><br /> TypeFromSample::New(MyClass);<br /><br /> <span class="rem">// Código de ejemplo de uso a partir</span><br /> <span class="rem">// del cual deseo armar el prototipo</span><br /> <span class="rem">// de MyClass</span><br /> MyClass^ var = <span class="kwrd">new</span> MyClass();<br /> var.Add(1, 2);<br /> var.CurrentValue = <span class="str">"string"</span>;<br /> var[2] = <span class="str">"test"</span>;<br /> <span class="kwrd">int</span> n;<br /> n = var.HashOf(<span class="str">"hola"</span>);<br /> n = var.foo(1, <span class="str">"chau"</span>, var, args);<br /> <span class="kwrd">return</span> 0;<br />}<br /></pre><br />Al compilar el cliente en modo interactivo se inferirá la siguiente estructura para MyClass:<br /><pre class="csharpcode"><br /><span class="kwrd">public</span> <span class="kwrd">class</span> MyClass{<br /> <span class="kwrd">void</span> Add(<span class="kwrd">int</span> p1, <span class="kwrd">int</span> p2){<br /> <span class="kwrd">throw</span> <span class="kwrd">new</span> NotImplementedException();<br /> }<br /> <span class="kwrd">string</span>^ property CurrentValue {<br /> get {<br /> <span class="kwrd">throw</span> <span class="kwrd">new</span> NotImplementedException();<br /> }<br /> set {<br /> <span class="kwrd">throw</span> <span class="kwrd">new</span> NotImplementedException();<br /> }<br /> }<br /> <span class="kwrd">int</span> HashOf(<span class="kwrd">string</span>^ p1){<br /> <span class="kwrd">throw</span> <span class="kwrd">new</span> NotImplementedException();<br /> }<br /> <span class="kwrd">int</span> foo(<span class="kwrd">int</span> p1, <span class="kwrd">string</span>^ p2, Sample::MyClass^ p3, <span class="kwrd">string</span>^[] p4){<br /> <span class="kwrd">throw</span> <span class="kwrd">new</span> NotImplementedException();<br /> }<br />}<br /></pre><br />La classfactory "TypeFromSample" puede mejorarse en muchas formas, por ejemplo:<br /><ul><li>Permitiendo inferir indexadores y constructores</li><li>Inferir todos los tipos faltantes (más de un tipo a la vez)</li><li>Presentar interfaz de usuario al programador para consultar sobre una desición de inferencia<br /></li></ul><br />La classfactory interactiva tiene menos de 100 líneas de código útil y permite implementar la inferencia de una clase de forma más completa que Visual Studio. Al tratarse de una classfactory interactiva en el futuro también podrá utilizarse para cualquier otro lenguaje LayerD de alto nivel que no sea Meta D++.<br /><br />A diferencia de una herramienta en un entorno intergrado la classfactory funciona de forma completamente independiente de cualquier entorno e incluso de cualquier editor de texto por ser procesada por los compiladores LayerD directamente, por tanto podemos utilizar su funcionalidad aunque programemos con Notepad. También es posible adaptar su comportamiento a lo que nosotros necesitemos, por ejemplo agregando inferencia de constructores, interfaces, métodos de colección, eventos, etc. y el trabajo que realizamos en dicha utilidad no perderá vigencia porque salga un nuevo entorno de desarrollo.<br /><br />Es preciso notar que en la actualidad no es posible desarrollar nada similar con ningún lenguaje main-stream sin utilizar el modelo de extensión de algún entorno en particular. En su lugar, LayerD permite desarrollar este tipo de herramientas típicas de entornos IDE directamente en el mismo lenguaje en el cual escribimos todos nuestros programas y usando el mismo conocimiento que poseemos del lenguaje y la programación de classfactorys en general sin atarnos a ningún entorno, versión, plataforma o fabricante en particular.Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-19313737591270584162008-04-29T22:56:00.004-03:002008-07-24T15:18:30.975-03:00Binarios de LayerD - SDK 0.5.0 AlphaAl fin no más promesas o fechas tentativas, esta vez release de verdad para todo el mundo. Veo que es tarde pero todavía es Martes 29 de abril de 2008 en Córdoba Argentina, como prometí el primer release de binarios con un "mini-SDK" de LayerD se encuentra disponible a partir de ahora y para siempre para todo el mundo que lo encuentre interesante.<br /><br />Primero, el link para bajar los binarios desde SourceForge: <a href="http://sourceforge.net/project/showfiles.php?group_id=212165">Download LayerD SDK 0.5.0</a><br /><br />Dividiré esta nota en dos partes: sentimentalismo y notas técnicas.<br />Si no le interesa mis pensamientos o sentimientos al respecto de éste release vea directamente las notas técnicas.<br /><br /><h3>Sentimentalismo del Release</h3>Desde que LayerD en su forma actual fue una idea halla por fines del año 2002 hasta ahora han pasado largos años y mirando para atras se sienten muchas cosas.<br />No fue sencillo desarrollar esta humilde pero pretenciosa tecnología cuando todo es realizado a pulmón. Sin embargo, a lo largo del camino que fue - y seguira siendo - el desarrollo de éste proyecto me encontré con muchas manos amigas que me ayudaron y bancaron de diversas maneras.<br />Ya no recuerdo cuantas veces pensé en tirar todo el proyecto literalmente a la mierda, "para que esforzarme con esto tanto". Pero por alguna razón todas esas ideas terminaron plasmandose en lo que hoy es LayerD como dije, en gran medida gracias a todas las personas que me ayudaron o apoyaron a lo largo de este tiempo.<br />Tengo que agradecer a mucha gente, en primer lugar a mi familia y a mis padres a quienes les debo casi todo lo que soy, en segundo lugar a Dios por permitirme vivir tantas cosas grandiosas, a todos mis amigos de siempre que implícitamente o explícitamente son un gran apoyo para mi siempre. A quienes siendo alumnos de la UTN-FRC se animaron a sumarse al proyecto ya empezado de otro alumno en el Laboratorio de Investigación de Software de la UTN, en párticular a Lucas Forchino, Demián Odasso y Alejandro Romero quienes me dieron una gran mano y aunque no lo sepan mucho animo para continuar con el proyecto, también a muchas otras personas que se acercaron al proyecto a todos ellos gracias!.<br />También quiero agradecer a Juan Carlos Vázquez quien me apoyo para poder llevar el proyecto desde mi casa al laboratorio de la facultad lo cual significo posiblemente que el proyecto no se cayera antes de dar algún resultado.<br />No puedo no agradecer enormemente a mis actuales compañeros de trabajo Javier Dall'Amore, Pablo Frias y Mateo Bengualid quienes se convirtieron en los tres primeros programadores de Classfactorys del mundo jaja - a parte de mi claro - y realmente no se quejaron cuando encontraron algunos de los infinitos bugs en el compilador Meta D++ y Zoe, gracias a ellos ahora son herramientas que se dejan usar mucho más!!<br /><span style="font-weight: bold;"></span>Seguro me estoy olvidando de agradecer a más personas, si sos uno de ellos perdón!!!<br /><br /><h3>Notas Técnicas</h3>El release es considerado SDK 0.5.0 por la sencilla razón de creer que en la actualidad los compiladores y herramientas entregadas poseen quizas la mitad de la madurez y funcionalidad que me gustaría tuvieran. Queda muchisimo trabajo por delante para terminar de implementar todas las funciones del lenguaje Zoe y Meta D++, los modulos de salida (bueno aquí el trabajo literalmente puede ser infinito por que se puede tener cuantos módulos quieras :-), lo mismo que en los meta-lenguajes y las líbrerias de classfactorys o clases ordinarias jeje ).<br /><br />Recuerden lo siguiente antes de ponerse a jugar con LayerD:<br /><ol><li>Se escribe el programa en Meta D++ (actualmente el único compilador de alto nivel LayerD disponible públicamente)</li><li>Se compila el programa con el compilador de Meta D++ (metadppc.exe).</li><li>Se compila el resultado (programa .zoe) con el compilador Zoe (zoec.exe).</li></ol>En el instructivo incluido en el paquete se explica brevemente la utilización de los compiladores, vea la ayuda de linea de comandos para más información - no todos los parámetros de los compiladores funcionan, la mayoría si.<br /><br />Sólo distribuyo el modulo de salida a .NET porque es el más trabajado y depurado, el módulo de salida Java seguramente estará público prontamente pero deberán de esperar al menos unas semanas dependiendo del tiempo que tenga.<br /><br />Y los releases a partir de ahora serán seguidos con cada versión un poco más completa y con menos bugs!! de los compiladores. Por favor, tengan en cuenta que en el release actual varias funciones importantes no están implementadas y no pueden considerarse versiones estables, ni siquiera betas para mi gusto - aunque muchas empresas comerciales lanzan "release candidates" en condiciones muy dudosas - prácticamente todo el código esta escrito aprendiendo sobre compiladores - antes no había desarrollado otros lenguajes o compiladores son mis primeros :-) - y en tiempo libre fuera del estudio y el trabajo. Más halla de estos detalles los compiladores permiten desarrollar cosas serias, de hecho ya hay varios miles de líneas programadas en LayerD siendo la mayoría de ellas Classfactorys :-), y todo eso en el marco de un proyecto comercial real, por tanto no hay pretextos para no probarlos!! ;-)<br /><br />Lo se, la documentación es escasa, pero lo ire subsanando de a poco, en una o dos semanas subiré un manual de Meta D++ y una versión actualizada de la especificación de Meta D++ (la actual en el sitio LayerD.net no esta actualizada), también estaré actualizando el sitio web LayerD.net que ahora no tuve tiempo de hacerlo.<br /><br />En lo subsiguiente empezaré a poner publicamente en SourceForge el código del proyecto. Empezando por el compilador Meta D++ y el Modulo de Salida Zoe a .NET, luego el código del compilador Zoe. Todo con licencias Open Source.<br /><br />Bueno, espero alguien pueda disfrutar y aprovechar estas herramientas!!! Espero el feedback!!<br /><br />Saludos !!,<br />Alexis FerreyraAlexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com2tag:blogger.com,1999:blog-1081586295700684533.post-60088412883728651562008-04-19T12:35:00.008-03:002008-07-24T15:15:42.943-03:00Nos encanta que nos mientanA los desarrolladores, ingenieros de software, analistas, etc. nos encanta que nos mientan. Luego de pensar por mucho tiempo y observar la conducta de mis pares durante algunos años y observando la reciente historia del desarrollo de software llego a ese inequívoca conclusión.<br />¿Por qué pienso esto? Para explicarlo me voy a ayudar con términos gráficos usando una burda línea del tiempo:<br /><br /><br /><p><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhP9bFBIafxuwX6xK2-y_1X0gR3I1vq-FCB6OPiKIBhuGbVqZzSxovIr-u3jpDV5MntZzRNPYKDCtA7UWn7bEHcTQ7Dpv1OJAFpFtSyzGmDlRg4z1GgJrP5tRHGmVX210G2wIOysGyyQbgF/s1600-h/text4631.png"><img id="BLOGGER_PHOTO_ID_5190982353668999810" style="DISPLAY: block; MARGIN: 0px auto 10px; CURSOR: hand; TEXT-ALIGN: center" alt="" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhP9bFBIafxuwX6xK2-y_1X0gR3I1vq-FCB6OPiKIBhuGbVqZzSxovIr-u3jpDV5MntZzRNPYKDCtA7UWn7bEHcTQ7Dpv1OJAFpFtSyzGmDlRg4z1GgJrP5tRHGmVX210G2wIOysGyyQbgF/s320/text4631.png" border="0" /></a><br /><br />La imagen superior muestra una improvisada reseña de algunas tecnologías recientes que se me vinieron a la mente - incluye un poco de todo, lenguajes, frameworks, librerías, etc. - y lo dibuje rápidamente con Inkscape :-).<br />No me critiquen los errores, ni la escala, ni el diseño gráfico inexistente, es algo aproximado, pero escucho sugerencias de cambios o cosas que me haya olvidado.<br /><br />Lo interesante es notar como en relativamente poco tiempo - 1990 a 2008 son 18 años - han pasado tantas tecnologías y herramientas que en definitiva sirven para lo mismo, hacen lo mismo, y lo que es peor nos venden los mismos fabricantes. Si usted es un joven y no conoce mucho de la historia reciente del desarrollo de software le recomiendo que investigue un poco para poder visualizar la cantidad de herramientas que hemos tenido que aprender quienes estamos en esto de la programación desde hace más de una década. De todas formas si todavía no sufrió el paso de una tecnología propietaria o "abierta" a otra "nueva" que hace lo mismo "pero es mejor" seguramente lo sufrirá próximamente.<br />Cuando se pasa por la situación de tener que reescribir nuestro software en varias plataformas, lenguajes, runtimes, pero que en definitiva ES LO MISMO, podemos tener dos reacciones: sentimos una profunda desesperación y llegamos a percibir lo precaria e involucionada de nuestra profesión, o nos ocurre lo contrario y reescribimos nuestros repetidos programas encantados de hacer lo mismo una y otra vez con cada "cosa nueva".<br /><br />Es entendible que las personas jóvenes, quienes estan hace poco tiempo en esto del software, se inclinen por la resignación o se vean sorprendidos cuando don microsoft (si con minúscula) les dice lo lindo que es .NET y como es mejor que todo lo anterior, o aplaudan a un "evangelizador" java cuando en una conferencia les cuenta lo hermoso de hacer programas SOA con java (si también con minúscula) y como perdieron el tiempo si habían desarrollado demasiadas cosas con EJB 2.0 usando algún ORB CORBA porque en definitiva ahora eso no es necesario. Lo que quiero decir es que entiendo que quienes tenemos menos experiencia - y me incluyo - nos creamos muchas veces esta dialéctica del "avance tecnológico" de las grandes empresas proveedoras de software de base y middleware.<br />Pero lo que no entiendo - o si lamentablemente - es que profesionales con muchos años de experiencia, con muchas tecnologías y lenguajes de programación en su espalda se lo sigan creyendo o al menos sigan realizando software sin importarles que lo que hoy estan escribiendo lo deberán tirar a la basura en un par de años cuando el framework de moda lo reemplaze.<br /><br />Gustave Eiffel, famoso ingeniero estructural frances, diseño junto a Emile Nouguier y Maurice Koechlin - principales ingenieros en Gustave Eiffel & Cia. - su aún más famosa torre Eiffel hace poco más de 120 años. Planeada desde 1884 y rechazada para ser construida en la feria mundial de 1888 en Barcelona se termino construyendo para la feria mundial de 1889 en Paris.<br />Proyectada inicialmente para durar 20 años la torre se volvió inmensamente popular recibiendo hasta la actualidad más de 236.000.000 de visitantes. Antes de su inauguración y durante su construcción recibió numerosas criticas de diversos artistas y personalidades, miedos de que la torre se cayera y causara un desastre, criticas a su "fealdad" y a su "desnudez".<br />Durante el dominio Alemán de Paris en la segunda guerra Hitler mando a desmantelarla, cuando los aliados se acercaban a la recuperación de la ciudad, pero el oficial a cargo ignoro la orden afortunadamente. Su principal mantenimiento es ser repintada cada siete años.<br />Eiffel explicaba a los críticos iniciales de la torre que su forma y apariencia "desnuda" era resultado de las matemáticas e ingeniería aplicada en el diseño para garantizar que la torre no se cayera sobre su propio peso, y más importante resistiera los embistes del viento. La ingeniería debía aplicarse para lograr construcciones solidas y duraderas.<br /><br />Lo de la torre es uno de tantos ejemplos en la ingeniería civil que se pueden encontrar para mostrar que en dicha disciplina "tener ingenio" y realizar construcciones durables, solidas y confiables, es posible.<br />Tal vez no es justo comparar la ingeniería estructural con la ingeniería de software, pero si ambas son ingenierías pienso que es valido comparar salvando las distancias, y pienso que es valido esperar que un día la ingeniería de software alcance y supere en sus construcciones la durabilidad y solidez en la ingeniería civil.<br />En los puentes, las torres, los edificios son las fuerzas de la naturaleza los que limitan la duración de una construcción.<br />En la ingeniería de software nuestro producto corre sobre nuestro propio mundo, en nuestro propio universo hecho a medida, dinámico como el mundo real, pero diseñado y construido por nosotros. En la ingeniería de software no existen huracanes, tornados, terremotos, erosión, gravedad terrestre, fatiga de materiales. Entonces deberíamos de preguntarnos que es lo que hace que el producto de nuestro trabajo sea tan poco solido, tan poco perdurable cuando en realidad contamos con un entorno "controlado" y diseñado por nosotros mismos - al menos por nuestros pares - y aún así el software que construimos es en general patéticamente frágil y perecedero. Difícilmente algún ingeniero de software hoy en día se anime a garantizar la durabilidad de un software por más de diez años, situación que encuentro muy graciosa teniendo en cuenta que el software es una abstracción y por tanto deberíamos de poder garantizar su durabilidad por lo menos por un par de siglos.<br /><br />Sin lugar a dudas, los ridículos resultados de la ingeniería de software tienen muchas causas y pasar de la prehistoria actual a la modernidad nos llevará un tiempo y se requerirá un cambio cultural y técnico muy importante. Pero debemos empezar a trabajar ya mismo para lograr ese cambio en las generaciones que vendrán. Hoy en día aunque existiera un Gustave Eiffel de la ingeniería de software no podría construir su torre por que sencillamente no contaría con los medios técnicos para realizarlo aunque poseyera el ingenio y la creatividad necesaria.<br /><br />Para comprender más lo precaria de nuestra situación basta con observar en las universidades - al menos las argentinas que son las que conozco, y entiendo no estan muy alejadas de las del resto del mundo - las carreras de sistemas. En mi querida UTN regional Córdoba, para poner un ejemplo, prácticamente sólo se enseña java y algo de .net, sólo el proceso unificado y el paradigma de orientación a objetos. Los alumnos luchan para hacer estúpidos ABMs de forma artesanal tal como un troglodita armaría una choza detrás de otra a mano porque no conoce ninguna técnica más avanzada ni cuenta con ninguna otra maquinaria o herramienta más que solo un destornillador.<br />En esa misma universidad un profesor de probablemente la materia donde más programación se ve en toda la carrera implementa un algoritmo de archivos en java usando: "longitudIndice = cantidad * 8" donde "8" es la cantidad de bytes en un tipo de datos "long" en java. Querido!! el long en java mide 8 bytes porque la JVM actual es de 32 bits, cuando se pase a una JVM de 64 bits ese software ya no funciona más. </p><p><em><strong>Nota:</strong> como me han hecho notar sabiamente mi ignorancia con la JVM 64bits, el ejemplo es incorrecto porque en la JVM actual de 64bits el long también posee 64bits -me temo que segui el pensamiento logico de pensar que en una plataforma de 64bits un "int" sería del tamaño de palabra de la plataforma es decir 64bits y por tanto el long debería ser de 128bits, estoy pensando que es más confuso que tener "long" que no son "long" :-). Esto no es así en la JVM de 64bits actual, lo cual no invalida de todas formas el ejemplo. Hardcodear un tamaño de tipo nativo en código que va a manejar archivos sigue siendo errado - mi humilde oponión es que lo correcto es poner "Long.SIZE / 8" a falta de un "sizeof" y teniendo en cuenta que el miembro SIZE en java devuelve la cantidad de bits lo cual ya si es indivisible e independiente de la plataforma de igual forma que el valor 8 que en este caso es el tamaño de un byte lo cual si es universal, pero de todas formas lo ideal sería que el lenguaje proporcionara un sizeof - desde el punto de vista de generar software multiplataforma y de larga duración, el punto del ejemplo sigue siendo el mismo, simplemente aceptamos la fragilidad del software y el alto acoplamiento con un runtime y plataforma en particular, ni lo pensamos, ni nos importa. Es curioso notar que en la especificación del lenguaje Java aclara que los arrays pueden contener un máximo de elementos basados en un indice de 32bits y es un error hacer: "long var=5; int mat[]=new int[5]; mat[var] =1;". Evidentemente ni los diseñadores de Java tuvieron en cuenta entornos de ejecución futuros y realmente tener un "long" que en realidad es un entero común en 64bits no es muy convincente, adicionalmente en memoria los tipos de datos de la JVM 64bits no ocupan necesariamente lo esperado, por ejemplo el long ocupa 128bits en el stack. Repito que no es un ataque a nadie, la idea es mostrar como no pensamos en ello, incluso personas con muchisima experiencia y conocimientos - como el profesor del ejemplo - no piensan en ello.</em></p><p>Básicamente, los profesores enseñan a los alumnos a construir casas con palitos y fósforos apilados. Pero no lo hacen por maldad, lo hacen por ignorancia, pero por sobre todo lo hacen por falta de profundidad y visión, es que se educaron durante años en un ambiente donde todo el mundo acepta que el software que construye es tan duradero como una escultura de hielo en epoca invernal o una de arena realizada en la playa durante la baja mar.<br /><br />Todos, quienes estamos en esta profesión debemos de cambiar nuestra manera de pensar, debemos de ser altamente críticos, constructivos, y entender que en la ingeniería de software existe prácticamente todo por construir e inventar, no nos tiene que gustar que nos mientan como nos mienten, el software actual es precario, frágil, caro, ineficiente. Las técnicas y herramientas son primitivas, observemos el diseño de la mayoría de los compiladores nada más, prácticamente no han cambiado en treinta años. Debemos ponerle pasión a nuestra profesión, ingenio, creatividad, debemos encontrar las herramientas adecuadas para construir mejor software, más sofisticado, a menor costo, más durable por favor!!! no puede ser que un software dure menos de cinco años, de hecho no deberíamos de aceptar ningún software que no dure al menos cincuenta años. Si lo que acabo de decir le parece exagerado al lector eso muestra que querido lector no posee la profundidad de visión ni la convicción en su profesión ni la confianza en si mismo de ser capaz de lograrlo lo cual creo muestra que mi punto sobre la precariedad de la ingeniería de software es acertado.<br /><br />La clave es ser activos en este problema y proponer soluciones al menos parciales. En una conferencia en Buenos Aires para el lanzamiento de .NET en Argentina en 2002 tuve la oportunidad de presenciar un auditorio lleno de profesionales aplaudiendo a la gente de microsoft con minúscula cuando les decían en la cara que todo el software desarrollado que tenían no servía más y lo tenían que reescribir en .NET o resignarse a que entre en estado de putrefacción mientras microsoft quita el soporte a sus plataformas anteriores. LOS APLAUDIAN!!!<br /><br />Ya venia pensando en algo como LayerD hacia unos años pero esa experiencia fue una de las cosas que me hizo decidir a dedicarle tiempo y tratar de proponer yo mismo un conjunto de herramientas para empezar a encarar la estupidez en la ingeniería de software.<br /><br />LayerD humildemente trata de considerar todos los principales problemas de la ingeniería de software a nivel global histórico y que tienen que ver con la baja durabilidad, calidad y el alto costo de desarrollo. Por tanto, LayerD provee medios para manipular de forma automatizada y programable cualquier componente de la implementación de un software - el código fuente - y mecanismos modulares para tener siempre una puerta abierta con la cual adaptar nuestra implementación a cualquier plataforma actual o futura. Sin lugar a dudas, LayerD distará de ser la herramienta y maquinaria perfecta, pero al menos proporciona medios para empezar a encarar este problema que no vemos y nos afecta a todos en múltiples niveles.<br /><br />Por ejemplo, mediante classfactorys es posible encapsular APIs y diferencias entre entornos de ejecución diversos de forma transparente y sin incurrir en perdida de performance necesariamente. Las classfactorys interactivas permiten encapsular herramientas RAD de forma independiente a cualquier runtime, lenguaje de alto nivel o IDE de desarrollo. La posibilidad de utilizar lenguajes de dominio especifico y programación orientada al lenguaje abre la puerta al diseño de software más abstracto, reutilizable y mantenible. Las capacidades de análisis de código en tiempo de compilación permite integrar herramientas que en la actualidad se deben manejar de forma separada y realizar análisis exhaustivos de código y son además sencillas de programar. A partir del 29 de abril del 2008 - cuando esten disponibles para todo el mundo que le parezca interesante - empezare a mostrar con ejemplos como estas palabras abstractas se convierten en algo concreto usando el framework LayerD.<br /><br />Con estos pequeños pensamientos espero despertar la curiosidad en los lectores e incitarlos a no conformarse con lo que nos venden y cuentan, ser críticos, buscar y desarrollar si es necesario mejores alternativas para elevar la calidad y durabilidad del software, para pasar en algún momento de la época de las cavernas a la modernidad. Espero sinceramente que la próxima década los ingenieros de software nos encontremos con un panorama mucho mejor en el cual dispongamos y sea común la utilización de nuevas herramientas como LayerD y otras similares que estan viendo la luz en estos días.<br /><br />La proxima vez que vayamos a una conferencia de estos "evangelizadores" y nos diga "esto si funciona, es mejor que lo que antes te dije que era mejor, esto es estándar y lo soportaremos por largo tiempo" no le creamos y mostremos nuestro dedo del medio bien en alto, le hagamos saber que no somos niños, somos adultos así que no nos vengan con soluciones baratas con escaza ingeniería y creatividad - por no decir cero -, perdón por el tono, pero el software es mi vocación y como todos los que amamos esto queremos contribuir en algo mínimo y es irritante como muchas empresas nos tratan como niños ciegos que no podemos ver más halla de nuestra nariz. Tratemos de ver el problema con profundidad histórica y técnica, de lo contrario nunca lo solucionaremos, si seguimos creyendo que un estándar - corporativo o no - durará por siempre y esperamos las soluciones a los problemas de nuestra profesión vengan de estas mismas empresas estamos perdidos.</p>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com3tag:blogger.com,1999:blog-1081586295700684533.post-56238851973301570632008-04-12T17:51:00.010-03:002008-07-24T15:17:47.521-03:00Guerra de Sintaxis, LayerD no va a la guerraDesde que aparecieron los primeros lenguajes de programación en la década del 50 aproximadamente - dejando de lado otros antecedentes históricos que pueden considerarse - todo el mundo ha discutido sobre la conveniencia o no de diferentes sintaxis a utilizar en los lenguajes de programación.<br />Lo cierto es que a la hora de diseñar la estructura léxica y sintáctica de un nuevo lenguaje de programación - hablando siempre de lenguajes cuya sintaxis es textual - deben tomarse decisiones de compromiso. Una decisión típica que debemos tomar es elegir si nuestro lenguaje será fácil de escribir o fácil de leer, o al menos eso hacemos.<br />La sintaxis de un lenguaje de programación es importante en muchos sentidos:<br /><ul><li>Es la cara visual del mismo</li><li>Si gusta a los programadores a la hora de escribir los programas sumará al lenguaje en popularidad.</li><li>Si es fácil de leer será más fácil mantener el código. Por el contrario, si es complejo de leer la manutención se dificultará.</li><li>Como en general se dispone de una única sintaxis puede limitar la adopción del lenguaje por muchos programadores a los cuales no les agrade inicialmente.</li></ul>A lo largo del tiempo cada lenguaje ha tenido que defender sus diseños sintácticos, por citar un ejemplo transcribo una porción de un manual de Python:<br /><br /><blockquote>...The indentation rule may seem unusual at first glance to programmers accustomed to C-like languages, but it is a deliberate feature of Python, and one of the main ways that Python almost forces programmers to produce uniform, regular, and readable code. It essentially means that you must line up your code vertically, in columns, according to its logical structure. The net effect is to make your code more consistent and readable (unlike much of the code written in C-like languages). To put that more strongly, aligning your code according to its logical structure is a major part of making it readable, and thus reusable and maintainable, by yourself and others. In fact, even if you never use Python after reading this book, you should get into the habit of aligning your code for readability in any block-structured language. Python forces the issue by making this a part of its syntax....</blockquote><br /><br />Se podrían citar decenas de ejemplos más, en definitiva cada uno de los lenguaje dirá lo mismo "que buena que es esta sintaxis en comparación con el lenguaje X por bla, bla, bla, bla".<br />A partir de ello uno podría preguntarse porque no han surgido lenguajes de programación para los cuales se puedan usar más de una sintaxis. El problema con éste enfoque es la complejidad que implicaría el mantenimiento si no contamos con algún mecanismo que vuelva transparente la traducción entre diferentes sintaxis, además del aumento en la dificultad a la hora de capacitar a los programadores.<br /><br />En última instancia el gusto personal de cada programador convierte la tarea del diseño de la estructura léxica y sintáctica de un lenguaje en algo mucho más cercano al arte y la subjetividad que a la ingeniería.<br /><br />Personalmente, siempre me molesto tener que seguir una sintaxis en particular a la hora de programar para determinada plataforma y también me he preguntado porque debemos usar la misma sintaxis para escribir un programa que para leerlo. Lo cierto que ya transcurrieron más de 50 años desde la aparición de los primeros lenguajes de programación de alto nivel y parece que todavía discutimos que estilo sintáctico es mejor para un lenguaje de programación cuando en realidad desde el punto de vista de un compilador y un entorno de ejecución la sintaxis utilizada para construir un programa es algo totalmente irrelevante. Los pilares de cualquier lenguaje de programación o entorno de ejecución son su estructura de tipos y las características semánticas asociadas. Me da toda la sensación que a estas alturas de la historia deberíamos de haber pasado a la adultez en la ingeniería de software y poder utilizar libremente diferentes sintaxis de acuerdo a nuestro gusto, humor y proyecto en el cual estemos trabajando. Tampoco deberíamos limitarnos a utilizar la misma sintaxis para leer los programas que para escribir, sencillamente es mucho más eficiente utilizar diferentes formatos para la escritura que para la lectura.<br /><br />En la actualidad, al menos en cuanto a entornos de programación populares, la única plataforma que ofrece cierta libertad a la hora de elegir la sintaxis es .NET de Microsoft. También se puede nombrar varios lenguajes de programación para la plataforma Java. Quizás, la limitación de estos lenguajes que apuntan al mismo entorno de ejecución es la falta de herramientas automatizadas para la traducción entre ellos, adicionalmente no siempre las características semánticas son completamente compatibles entre los diferentes lenguajes. Adicionalmente, no se poseen herramientas que nos permitan utilizar diferentes sintaxis para leer los programas de manera sencilla o al menos usadas de forma masiva.<br /><br />Por estas razones, a la hora de diseñar LayerD quise asegurarme de poder utilizar múltiples sintaxis y evitar esas largas discusiones sobre que sintaxis es mejor para escribir un programa o que sintaxis es más adecuada para leerlo y mantenerlo. El 99,9% de los lenguajes de programación actuales combaten en la guerra de sintaxis desde que nacen, con un poco de suerte en el caso de los lenguajes de alto nivel dentro el framework LayerD eso no será así.<br /><br /><div><blockquote>LayerD no va la guerra de sintaxis.</blockquote></div><br /><br />Con LayerD se puede elegir entre diferentes sintaxis para escribir los programas y se posee una multitud más de formatos para leerlos. Ok, en sus primeros meses no se poseerán muchos lenguaje LayerD de alto nivel - llamados meta-lenguajes - ya que en la actualidad disponemos del meta-lenguaje Meta D++ - el cual posee una sintaxis heredada de C++ y en parte de Java y C# - y el lenguaje Argentino - cuya sintaxis es tipo pascal pero en español, Ok necesito que Lucas Forchino termine esto que me lo prometió :-) - te quiero amigo jeje -, y finalmente más cerca de mediado de año se contará con un clon de C# el cual implementará un subset de la sintaxis de C#.<br /><br />Esto es posible por la naturaleza modular de LayerD y la necesidad de todo meta-lenguaje de generar código en el lenguaje intermedio Zoe. Es interesante mencionar, que construir un meta-lenguaje para LayerD es relativamente sencillo ya que sólo se requiere programar un analizador léxico y uno sintáctico, luego el compilador Zoe se encarga del resto.<br /><br />Para no olvidarnos de los problemas que nos pueden traer aparejado tener varias sintaxis para programar en una misma plataforma, la mayoría de los meta-lenguajes podrán traducirse de forma automatizada a otros meta-lenguajes utilizando el compilador Zoe y su proceso de "compilación interactiva" - lo cual es toda otra historia con muchos cuentos interesantes para otro día :-).<br /><br />Tampoco me olvide de encarar la idiotez sintáctica en los lenguajes de programación y utilizando hojas de estilo se pueden leer los programas escritos en cualquier meta-lenguaje y compilado al código intermedio Zoe con un formato diferente al de escritura y por tanto optimizar la sintaxis para lectura y análisis de un fuente. Poseer una estructura sintáctica diferente para la lectura de un programa LayerD es tan sencillo como contar con una hoja de estilo aplicada al código Zoe que es XML.<br /><br />Con suerte muchos programadores estarán de acuerdo en terminar con las guerras sintácticas y empezar a utilizar plataformas que permitan decidir que sintaxis utilizar cuando se escribe un programa y que formato visual usar a la hora de leer y examinar programas. LayerD provee un empujón a dicho enfoque permitiendo tener múltiples sintaxis de alto nivel a un costo relativo bajo - desarrollar un meta-lenguaje -, permitiendo traducir entre ellos de forma automatizada y abriendo la puerta para empezar a diferenciar lo que nos conviene a la hora de escribir programas y a la hora de estudiarlos.<br /><br />Espero comentarios y pensamientos al respecto, si tengo tiempo amplio el post con gráficos y ejemplos de LayerD.<br /><br /><span style="font-weight: bold;">PD: 29/4/2008 se publicará en éste blog o el sitio web de </span><a style="font-weight: bold;" href="http://layerd.net/">http://layerd.net</a><span style="font-weight: bold;"> la primera versión binaria publica de los principales compiladores del framework LayerD así todos pueden empezar a jugar.....y a insultar los bugs. </span>Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com0tag:blogger.com,1999:blog-1081586295700684533.post-44493813268293323742008-04-02T20:04:00.004-03:002008-07-24T15:18:08.970-03:00¿Qué diablos es LayerD?<a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhR199nK4JIzK1Pj1uPvFehufETYExzxnLXBc1OKmg-CGz15u5FkJFh0dP7MxXwdz-R6rjG_JM75DbBIPBv2lChmJXDLRITxiS5oF5pYXFP6ODWTMZyoWsBKfVETKfNNcDV0s7lpM1B_BhO/s1600-h/proceso_layerd1_esp.jpg"><img style="margin: 0pt 10px 10px 0pt; float: left; cursor: pointer;" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhR199nK4JIzK1Pj1uPvFehufETYExzxnLXBc1OKmg-CGz15u5FkJFh0dP7MxXwdz-R6rjG_JM75DbBIPBv2lChmJXDLRITxiS5oF5pYXFP6ODWTMZyoWsBKfVETKfNNcDV0s7lpM1B_BhO/s320/proceso_layerd1_esp.jpg" alt="" id="BLOGGER_PHOTO_ID_5184788872290193490" border="0" /></a>Si ingresaron a esta página por error, o porque alguien más le paso el link pero nunca antes habían escuchado sobre el proyecto LayerD, nunca visitaron su sitio web, o si visitaron su sitio web pero no entendieron nada y no quieren leer durante horas para saber que diablos es esto del proyecto LayerD, intentaré explicarlo en esta entrada lo más sintético posible.<br /><br />Desde que inicie el proyecto LayerD en su forma actual alrededor del 2002 siempre se me complico a la hora de explicarlo, sus alcances y su razón de ser. De hecho me ha resultado casi imposible poder ponerlo todo de una forma coherente y creíble en un paper de 10 páginas.<br /><br />He escuchado de todo cada vez que una persona lee algo de la <a href="http://layerd.net/">página del proyecto</a> y me cuenta lo que opina o lo que entendió.<br /><br />Cosas como:<br />- LayerD es un traductor de código.<br />- LayerD te permite escribir un programa en .NET y ejecutarlo en una JVM.<br />- LayerD es un procesador de templates.<br />- LayerD es basura.<br />- No entiendo cual es el sentido de hacer tanto lío!!<br />- LayerD es como .NET pero sirve para Java.<br />- Que es LayerD es lo mismo que LayerD D++?<br />- LayerD es un traductor de lenguajes.<br /><br />La verdad que al escuchar cada una de esas "conclusiones" me daba cuenta lo mal explicado - o lo difícil que es explicarlo en ocasiones - y la verdad es que explicar que es LayerD de una manera sencilla depende del nivel de conocimientos. Si pregunta un estudiante de ingeniería en sistemas o un programador aficionado que sólo a usado lenguajes como Java, .NET, C++, Visual Basic, la respuesta es de una forma. Si pregunta un programador experimentado en lenguajes dinámicos como Lisp, Ruby, Python, Smalltalk la respuesta es más sencilla en cierto punto. Si pregunta una persona con experiencia y conocimientos en meta-programación, lenguajes dinámicos, programación declarativa, intencional u orientación al lenguaje entonces la respuesta es más fácil.<br /><br />Por tanto voy a responder a la pregunta de ¿Qué diablos es LayerD? teniendo en cuenta estas clasificaciones.<br /><br />Y si quieren una respuesta lo más escueta posible y exacta la respuesta es:<br /><ul><li><span style="font-weight: bold;">LayerD</span> es un framework que permite desarrollar software realmente abstracto.</li></ul><br />Ahora las respuestas para las clasificaciones anteriores, aunque quizás no sea mala idea leerlas a todas:<br /><br /><ul><li><span style="font-weight: bold;">Si conoces sobre meta-programación, programación declarativa, MOPs, paradigmas como orientación al lenguaje y programación intencional:</span> LayerD es un framework compuesto por múltiples lenguajes de alto nivel - los cuales aislan de una sintaxis en particular - y un lenguaje intermedio común denominado lenguaje Zoe el cual posee capacidades de meta-programación completas en tiempo de compilación y una generación de código modularizada. Las capacidades de meta-programación del lenguaje intermedio Zoe permiten desarrollar fácilmente DSLs, nuevas construcciones semánticas y programar cualquier tipo de análisis y transformación en tiempo de compilación utilizando un árbol sintáctico abstracto marcado semánticamente. Los múltiples lenguajes de alto nivel como entrada además de permitir aislar al programador de alto nivel de una sintaxis en particular permiten utilizar de forma sencilla "skins" de lectura teniendo en cuenta que el lenguaje común intermedio (Zoe) es xml. La generación de código es completamente modular y es posible "enchufar" módulos para integrar diferentes runtimes ya sean nativos, maquinas virtuales, interpretes, etc. Por todas estas características LayerD permite utilizar múltiples paradigmas - aunque esta basado en orientación a objetos - y además desarrollar software multiplataforma real.</li><li><span style="font-weight: bold;">Si conoces sobre lenguajes dinámicos como Smalltalk o Lisp: </span>LayerD posee multiples lenguajes de alto nivel, por tanto se puede programar con diversas sintaxis. Sin embargo, todos los lenguajes de alto nivel generan el mismo código intermedio: código en lenguaje Zoe. El lenguaje Zoe posee en tiempo de compilación - esto es mientras se esta compilando, no en tiempo de ejecución - características "similares" a los lenguajes dinámicos que te permiten examinar y modificar el programa que se esta compilando - obvio que de forma controlada - permitiendo realizar muchas de las cosas que se pueden hacer con un lenguaje dinámico pero mientras se compila el programa, luego en tiempo de ejecución se usa un runtime nativo y estático - a no ser que no querramos - por lo tanto no tiene penalidades de performance en tiempo de ejecución. A diferencia del común de los compiladores la generación de código e importación de tipos esta modularizada, por tanto enchufando modulos para diferentes runtimes puedo utilizar todo lo que ya existe en runtimes existentes como .NET, Java o el API nativa de un sistema operativo. Todas estas herramientas - más otras características - nos otorgan un balance entre la flexibilidad de los lenguajes dinámicos y el rendimiento de los lenguajes estáticos. En LayerD es relativamente sencillo programar lenguajes de dominio especifico, extensiones semánticas y técnicas de programación orientada a aspectos y declarativa. Como el árbol sintáctico en tiempo de compilación posee información semántica es posible realizar multitud de análisis en él.</li><li><span style="font-weight: bold;">Si es un estudiante o programador en lenguajes "populares" como Java, C++, Visual Basic, C# y no conoce demasiado sobre lenguajes dinámicos o funcionales o meta-programación y paradigmas como la programación declarativa u orientada al lenguaje: </span>Es usted la clase de persona a la cual le costará más llegar a entender LayerD pero por sobre todo llegar a comprender la clase de cosas que es posible programar con esta tecnología. Pero no se impaciente. En primer lugar en LayerD se puede programar en varios lenguajes de alto nivel, y cualquier empresa o persona puede desarrollar su lenguaje de alto nivel para LayerD, esto es comparable a .NET donde se poseen multiples lenguajes y todos generan código intermedio para el mismo runtime - ok JIT compiler jeje. En LayerD todo programa compila a un lenguaje intermedio denominado Zoe, dicho lenguaje posee un compilador modular al cual se le pueden programar "funciones adicionales" y se puede seleccionar la generación e integración con diversos runtimes como una JVM o un .NET runtime o directamente generar código nativo para un sistema operativo y plataforma de hard. Las "funciones adicionales" que se pueden programar en el lenguaje central a LayerD - y por tanto ser compartido por los lenguajes de alto nivel - pueden pensarse como nuevas estructuras semánticas. Por ejemplo, digamos que nuestro lenguaje de alto nivel posee nativamente un ciclo for común, pero no un ciclo for automático para colecciones, en LayerD se puede extender el compilador central para incluir un ciclo for para colecciones. Otro ejemplo, si deseo una instrucción que me permita ejecutar de forma concurrente - en hilos separados - una serie de instrucciones simplemente programo una extensión para el lenguaje Zoe - el lenguaje intermedio común - y utilizo esta nueva funcionalidad en cualquier lenguaje LayerD de alto nivel.</li></ul>Es difícil decir si estas explicaciones son suficientes, por las dudas enumero algunas de las cosas que nos permite hacer LayerD al programar:<br /><br /><ul><li>Utilizar un sólo lenguaje de alto nivel y hacer programas para diferentes runtimes como JVM, .NET o código nativo.</li><li>Hacer programas multiplataforma, es decir programas que escribo una vez y compilo para diferentes runtimes. Por ejemplo, un programa que compile nativamente para .NET, Java y código nativo sin ningún cambio en el código fuente.</li><li>Implementar Lenguajes de Dominio Especifico, como lenguajes para describir interfaces gráficas, lenguajes para describir modelos de entidades con sus relaciones y que implementen automáticamente todo el acceso a datos, lenguajes para chequear reglas de negocios, generar web-services, etc.</li><li>Hacer análisis de código en tiempo de compilación emitiendo errores, advertencias y notificaciones al programador.</li><li>Forzar reglas semánticas más estrictas a los programadores de alto nivel mediante una extensión para el compilador. Por ejemplo forzar a cumplir la arquitectura en capas o no utilizar campos públicos.</li><li>Realizar cualquier proceso de meta-programación durante el proceso de compilación.</li><li>Crear programas que se corrigen a si mismos durante la compilación y corren en tiempo de ejecución sin penalidades ni errores.</li><li>Me permite utilizar mis componentes desde diferentes lenguajes de alto nivel con diferentes sintaxis.</li><li>Permite utilizar una sintaxis para escribir los programas y otras diferentes para leerlos.</li><li>Permite reutilizar todo el código existente, no se deben volver a escribir librerías!!! se puede usar lo que ya existe en .NET, Java o la plataforma a la cual apuntemos nuestro software.</li><li>Permite desarrollar "librerías activas", esto es librerías que analizan la forma en la que son usadas en el programa cliente y corrigen su utilización o emiten advertencias y consejos, por que no, librerías que chequean vía Internet la compatibilidad con el programa escrito.</li><li>Permite desarrollar herramientas RAD de forma independiente al entorno de programación, como herramientas de refactoring o templates de código.</li></ul>Tal vez, encuentre todo esto como exagerado pero a lo largo de los post en éste blog iré mostrando ejemplos de cada uno de los tópicos y le proporcionare las herramientas básicas para que usted mismo pueda realizarlo.<br /><br />En estos días sólo tendrá acceso a los binarios de LayerD si es mi amigo :-), si no lo es tendrá que esperar unas semanas, prometo - y siempre trato de cumplir mis promesas - que para fin de mes publicare los binarios que tenga del proyecto LayerD, así en mayo ya podremos empezar con los ejemplos y uds. seguirlos.<br /><br />No están publicados aún porque se encuentran en desarrollo, sin embargo para su tranquilidad le cuento que ya lo estamos usando en un proyecto de producción real y funcionan lo suficientemente bien como para "dejarse usar". Los fuente se iran liberando en la comunidad open source de a poco, la razón de no liberarlos ahora es muy sencilla, no quiero liberar código que no tenga cierta mínima calidad y nivel de avance en cuanto a la funcionalidad.<br /><br />De acuerdo a su nivel de conocimiento puede tener mucho que aprender - o no - para explotar LayerD al máximo, sin embargo para empezar a usarlo y beneficiarse de a poco de las técnicas de meta-programación, orientación a aspectos, programación declarativa y custom DSLs no debe aprender nada fundamentalmente nuevo, ya que podrá utilizar todo lo que ya conoce en su plataforma ya sea .NET o Java.<br /><br />Saludos!Alexis Ferreyrahttp://www.blogger.com/profile/14960950658517661830noreply@blogger.com2