Archive for the ‘ideas’ Category

StrongRuby : gradual typing for Duby.

Abstract :

 

Static and dynamic type systems have well-known strengths and weaknesses. Statically typed programming languages incorporate a built-in static type system. Every legal program must successfully typecheck according to the rules of the type system.

 

Gradual typing provides the benefits of both static and dynamic checking in a single language by allowing the programmer to control whether a portion of the program is type checked at compile-time or run-time by adding or removing type annotations on variables. , that have no effect on the dynamic semantics of the language.

 

The complete proposal here : strongruby.pdf

GSoC 2007 Accepted.

My Ruby proposal Cover the core of Ruby with Rspec was accepted. I think its gone to be a great summer for me, working and learning with really intelligent people, and with a cool language and framework.

——————————————————————————————————–

Dear Applicant,

Congratulations! This email is being sent to inform you that your
application was accepted to take part in the Summer of Code. Please
check your student home page in the SoC web application at
http://code.google.com/soc/student_home.html to determine which of
your applications was accepted.

Over the next few days, you will be added to a special members only
Google Group
(http://groups.google.com/group/google-summer-of-code-students-list).
Please take a moment to browse the archive before posting.  We prefer
most of the program discussion to take place on the program discussion
list.  However, the students list is a private place for communication
about subjects where our student participants prefer to not
communicate the matter more widely.  You can find more information
about the program mailing lists here:
http://groups.google.com/group/google-summer-of-code-announce/web/guide-to-program-mailing-lists

Your mentoring organization may also set up similar mailing lists for
you and your cohorts so that they may interact with you on your
project. You should not wait for them; please feel free to contact
your mentor and let them know you are ready to start engaging with
your new project community.

You should also get into the habit of visiting your student home page
on a semi-regular basis, as we will track status, payments, paperwork
and take final surveys from this page.

If you have questions regarding payment, please wait until you see a
message from Leslie Hawthorn detailing what we will need from
you. This will take a few days as we button up the web application and
make sure all the students are properly assigned to the proper groups.

If you cannot take part for some reason, please email us at
gsoc@google.com as soon as possible so that we can allocate your slot
to another student.

Other questions and concerns should be send to gsoc@google.com

Thanks for taking part; we’re very excited to see what the Summer will bring!

Congratulations once again,

The Google Summer of Code Progam Administration Team

GSoC : Seaside and Sails : A generation code tool

=== Abstract ===

This proposal will provide, by the end of the summer, a tool that bring a structure generation to Seaside. This piece of software enhance Seaside with generators tools, commands and conventions that help programmers to develop CRUD-style web applications in Seaside in a much faster approach. Other of the goals of this project is create an extensible code generator that provide the infrastructure to develop custom generator easily

Create, retrieve, update and delete (CRUD) are the four basic functions of persistent storage, a major part of nearly all computer software. Also Each letter in the acronym can be mapped to a standard SQL statement. CRUD forms the basis of most dynamic websites in that they generally have data and function that:

* C reate new records (INSERT)
* R ead existing records (SELECT)
* U pdate existing records (UPDATE)
* D elete existing records (DELETE)

While you’re developing web applications, especially those which are mainly providing you with a simple interface to data in a database. Scaffolding is a proccess that generate the basic classes to create a CRUD-style web.

When creating or editing an entry, Sails scaffold will do all the hard work of form generation and handling for you, and will even provide clever form generation, (via extensibility).

This tool provides a model and its views, as starting point to development, which allows you to see add, delete, show and list the model data. Also the scaffolding process will generate test methods.

Other frameworks scaffolding creates text files that, when run, create the actual class. Sails shouldn’t create a script, but instead create the class immediately.

=== Why scaffolding ? ===

1) Scaffolding provides clear directions : Offer step-by-step directions to develop just what developer must do in order to meet the expectations for the learning activity

2) Scaffolding clarifies purpose : Why are we doing this? Scaffolding keeps purpose and motivation in the forefront.

3) Scaffolding keeps students on task : By providing a pathway or route for the learner,

4) Scaffolding offers assessment to clarify expectations :From the very start, scaffolded lessons provide examples of quality work done by others.

5) Scaffolding reduces uncertainty, surprise and disappointment :

7) Scaffolding delivers efficiency : If done well, a scaffolded templates should nearly scream with efficiency.

=== What make scaffolding and the order command for us ? ===

* One-step creation of components using a template, including models and views. (probably using Magritte)
- The model
- The view with the four basic operation method. Create/read/update/delete (CRUD), list and style method,
- The database scheme

* Easy creation of tests: using Sunit
- unit tests
- functional tests
- performance tests

* Easily connect to persistence layers, create the basic features for CRUD operation in the model. (probably using glorp)

* Help int the deploy application generating a set of commands that :
- Start the server. // WAKom startOn: 9090.
- Register the application // registerAsApplication:
- ….

* Only database Configuration of this tool will be necessary. Code convention over code configuration.

=== Benefits for The Seaside Community ===

Seaside will be powered by a structure code generation. It will accelerate the development cycle, supporting generation for models, views, test, and allowing the user to design and implement custom generators.

While a new framework has a shallow learning curve for Java, JSP, PHP, Python guys, Seaside is much, much different. Structure generation drastically lowers the learning curve by teaching the conventions through code instead of documentation.

=== Development plan : ===

The next planning describe the different milestones of the project. will probably vary during development.

1 Research (1st week)
* Identify the best practices, code conventions and structure convention of a Seaside application
* Identify the common manual task in a Seaside development cycle
* Identify Smalltalk idioms
* Define the commons action in all the task (create a class, define methods, …)

2 Implement the kernel classes, with only basic features. (2nd week)

3 Integrate Magritte with the kernel of the framework to generate the views (3rd week)

4 Integrate Sunit with the Kernel framework to generte unit test (4th week)

5 Implements connectors to the database. (Using glorp) (5th week)

6 implements helpers to deploy the application (6th week)

7 Adding Generator class loaders.(6th week)

8 Implementation of user intefaces (commands for the workspace) (7th week)

9 Extensive testing (Unit Testing)(8th week)

10 Documentation and tutorial. (8th week)

=== Basics generators class hierarchy ===

The next hierarchy is a first approach and must be take like a sketch not like a final version,it will be improve or refactoring. Its represent the object hierarchy.

–|
|– BaseGenerator
| |
| |– ApplicationGenerator
| | |
| | |– seasideAppGenerator
| |
| |– TaskGenerator
| | |
| | |– ModelGenerator
| | |
| | |– ViewGenerator
| | |
| | |– TestGenerator
| |
| |–
| |
|
|– scriptsDeployGenerators
|
|–
|
|– gen // a command line (workspace) for the generators.

=== Related programming techniques : ===

* Reflection.
* Metaprogramming.
* Structure code generation.

=== Related frameworks: ====

* SUnit
* Magritte

=== About me: ===

I am 28 y.o., and I am 5th year student of Computer Science at Universidad de Granada, Spain. I’ll graduate in about 9 month. My interests are virtual machines, web technologies, object-oriented systems, functional languages and many other things.

I work in software company in Hamburg, Germany. My current duty is Ruby/Rails development. My graduate work in university is dedicated to applying Latent Semantic Indexing to natural languages processing.

I also have extensive experience in the Linux-Tomcat-Java-Struts architecture.

My relevant skills include proficiency in C, Java, Lisp, Ruby the standard GNU development tools (gcc, automake, etc.), Java tools (Xdoclet, ant, maven), CVS/SVN, and a host of other smaller languages and tools. I’ve been involved in the open source community for a while. I help to build and configurate http://javahispano.net Gforge (sourceforge) site for the Java spanish spoken community.

=== Motivation and interests: ===

Why I want to take part in it… I’ll be honest. I saw Seaside at the first time, when I read a post ‘on smalltalk blog’ comparing Rails vs Seaside a month ago. I was surprise about this new way to develop web application. And I liked it.

In my first year in the university I have gone to a ground OOP course using Smalltalk.

I spend the last year working with rails. I wrote custom generators and rake task for my employer. I love ruby/rails tools, like rails_generators system or rake, and the way they reduce the time i spend in front of the IDE.

So, I think, I can do this task.

=== Available time: ===

In the beginning of the project (to the end of June), I will be somewhat limited by school – our semester ends by the end of May, followed by one month reserved for exams. During that time, I will spend some time learning and doing exams, so I cannot commit myself into this project fully during June. But I am sure I will be able to find time. After that, I will have 2 months holiday that I plan spending fully for the project.

GSoC 2007 : Ruby Code Browser.

molerubybrowser.pdf

[update] : I update the proposal, in order to apply again this year.

Ruby developers use intensely metaprogramming techniques, to create domain specific languages, to develop frameworks or to do a little bit of ruby magic. The ruby browser describe in this paper is a tool that help developers to inspect their classes

The goal of this projects is create an interactive graphical user interface of the irb-console with some extras features that allow a easy way to inspect (run-time introspection) the state of the objects.

The projects don’t pretend replace the irb console, the goal is integrate it in a graphical enhancement environment.

The ruby browser is directly inspired on the Squeak Browser, a graphical interface that allow to navigate throw all the classes and objects inside of the Squeak virtual machine.

When I’m writing a program in Smalltalk, I start a Workspace. Type in some code and evaluate it and open it up in an Inspector. As the program grows, I start refactoring the code in the Workspace into classes and inspecting it. At this point, I have an inspector open on some object. I can go in and modify or add methods in the class and evaluate them in the Inspector. I can open up inspectors on the results of those method calls, and so on… Is the same as we can do in Ruby with the irb with a non graphical, non intuitive console.

=== Functionality : ===

The ruby browser main features are :

——- Image paradigm
* Serializing the objects.
* Replicate the load “image” concept,
* Replicate the Save “image” concept.

——- Introspection
* Show all the classes already loaded in the console.
* Navigate throw the classes or modules.
* Add/remove methods and attributes to a class on the fly.
* Track the list of instances of a class
* View the list method of a live object.
* View the code of a method from a live object.
* Inspect an instance state.
* Show the hierarchy of class.

——- Evaluation
* evaluate code in a irb integrated console

=== Benefits to the Community ===

Static vs. Dynamic is missing some points. One of those points is interactivity. If we can inspect faster and easiest our code, we can interact and modify the objects and their definitions at runtime you gain a huge productivity boost.

Also whit a GUI enhancement irb console reduce the learn curve, for those who already don’t know object oriented programming. Thy can have a graphical representation of the object that they created in the console.

=== Development plan ===
….

=== Related gems : ===

* Ruby2ruby : ruby2ruby

=== About me: ===
…..

=== Available time: ===
…..

=== References : ===

http://www.notarianni.org/index.php/2005/09/17/object_orientation_enlightenment

Follow

Get every new post delivered to your Inbox.