RubyLit - Ruby.del.litoral!

Tutorial de Git

Tue, 20 Jul 2010 19:51:54 Z

Tutorial git
Original source: http://hoth.entp.com/output/git_for_designers.html

Version control, also known as source control or revision control is an integral part of any development workflow. Why? It is essentially a communication tool, such as emails or IM, but it works with code instead of human speech.
Version Control

Allows programmers to easily communicate their work to other
Allows a team to share code
Maintain separate versions of “production” are always deployables
Allows the simultaneous development of different characteristics in the same code base
Keeps track of all the older versions of files like “Point of Sale Software” http://www.merchantos.com/
Prevents overwriting work

What is version control?

Version control, alternately known as source control or source code management is a system that maintains versions of files in the progressive stages of development. The version control system is similar in theory to back up your files, but smarter. Each file in the system has a complete history of changes, and can be easily restored to any version of history. Each version has a unique identifier that looks like a string of letters and numbers. (443e63e6..).

There are many different software version control. This document is based on git, but also can study Subversion (SVN), CVS, darcs, Mercurial and others. Each has a Slightly Different metaphor for operation.

Repository Structure
The simplest version of the version control system consists of a repository where all the files and their live versions. Just a repository works as a database, you can return any version of any file in, or change history of any file, or perhaps a history of changes through the entire project.

25 Joe Adjust user profile information
24 Fred Add login box
23 Mary Allow user uploads photo
22 Joe Change the color of the header to yellow
21 Mary Change the header to blue
The user repository can check out a working copy, which is paying attention in recent copies of files that users can apply changes. After making some changes, users can then type in (check in or commit) the changes to the repository, which creates a new version with metadata regarding changes that were implemented and the person who made them.

http://hoth.entp.com/output/scm.png

Figure 1: A basic version control

While the simplest way is to have a canonical source for the repository, this is not necessary. Each user has a complete copy of the repository on your local machine. Generally, you apply changes to your local repository, and once it is complete, press down (push) your work to the shared repository on your computer. You can also pull (pull) of changes in other repositories

http://hoth.entp.com/output/dscm.png

Figure 2: A system of distributed source control

Branches (Branches)
The branches serve the same role that the draft when you write an email. You can work on a draft, saving it frequently until it is complete., Then, when ready, send email, and the draft is eliminated. In this case, the Sent folder does not pollute with your changes frequently, until you press “send.”
The branching is useful when developing new features, because it allows the teacher-branch Sent folder – be always working and deployable. It can be any number of experimental-draft-branches in active development. The branches are easy to create and exchange.
Once the code is finished in a branch and the branch passes its tests, the changes are mixed (merged) into the master branch and the branch is removed, as with mail draft. If someone applies for code changes (commit) to the master branch, it is easy update the master code to the last branch.

Workflow (Workflow)
Attack of the Clones
To have a working copy of your code base, you need to clone a remote repository on your local machine. The cloned creates the repository and gets the latest version, which is referred to as HEAD.
We cloned an open-source project.
$ Git clone git: / / github.com / wycats / jspec.git
Initialized empty Git repository
Congratulations, you’ve cloned your first repository. Command Sets clone and convienientes few items for you, keeps the original repository address, nickname given him in origin, so that you can easily send the changes back (if you have permission) to the remote repository.
JSpec now have a folder in the current directory. If you cd into that directory, you should see the contents of JSpec source code (they are only a few files)
Git can run on many protocols, including “git: / /” as above (most public projects use git ://). By default, git uses the ssh protocol, which requires you to have secure access to the remote repository.
$ Git clone user@yourserver.com: thing.git
You can specify the details of your authorization to ssh as above,

Making changes

Now that you have a working copy, you can start making changes. There is nothing magical about editing files, so all you need do is edit the files you whatever and then save them. Once the file is saved, you need to add (add) a change to the current revision (or more typically, you will make changes to several files and add them to the current review all at once). To do this, you need to git add to add the file with changes. This is known as “staging.”
$ Git add index.html
Or you can also add an entire directory at once,
$ Git add public /
That will add any file in the public / a review, or add the current directory:
git add.
If you make any changes after staging (before commit), you need to git add the file again.
Git status command displays the current status of the repository.
ninja-owl: public Courtenay $ git status

On branch master
Changes to be Committed:
(Use “git reset HEAD <file> ...” to unstage) #
Modified: public / index.html #
Git diff command shows you a view that difference is what has changed. By default, shows the changes that have not been “Estager.” Adding the flag ” cached” show changes “Estager” only.
ninja-owl: public Courtenay $ git diff – cached
diff – git a / public / index.html. b / public / index.html
100 644 index 754492nd a04759f ..
— A / public / index.html
+ B / public / index.html
-8.7 +8.6 Source code revision control or management, is a system That Maintains versions

This That I added a line to the file
This is a line I removed from the file
This output is called a diff or match and may be sent by email to other developers so that they can apply your changes to your local codes. It is also human-readable: shows the file names, line numbers within the file, and changes with the symbols and . You can also tubing (pipe) the diff to a file.
ninja-owl: public Courtenay $ git diff – cached> line_modify.patch
Commit (commit) something in your life
When you have your changes so you want to add them to the current revision, then you need to commit (commit) this review to your local repository. To do this, you will need to run git commit. When you execute this command, you receive a text editor with a list of files that have changed and some empty space at the top. In this space, you need to describe what has changed so that your colleagues can tell at a glance what you have done. Need to enter something better than “thing”, but there is no need to write a will, and instead do something like:
434 in line Changed index.html to use Rather Than spaces tabs.
Changed line 800 in products.html.erb to Have Space Between the two tags.
Changed line 343, 133, 203, 59, and 121 to Have two spaces at the start Rather Than 9.
Corrta A description of what you have changed will be sufficient. The commit messages are an art form, like haiku.
Minor formatting changes file in the code.
It is acceptable to write a summary line (less than 80 characters), a blank line, then a third line describing in more detail. The second and third lines are optional.
Once you’ve written the commit message, save the file and quit the text editor. This will commit to your local repository, and you can continue with your work.
Push back
Once your changes have been “committed” to your local repository, you need to push (push) the remote. To do this, you will need to run git push, which will push all changes from your local repository to the remote.
The push to git takes several arguments:

git push <repository> <branch>
</ Pre>

In this case, we want to push changes back to the original repository, which is "nicknamed" as origin, to the branch master.

<pre>
$ Git push origin master
</ Pre>

Fortunately for our fingers, push git (and git pull) default push and pull of all the branches common to the origin and local repository.
As you do push, you should see output similar to the following:

<pre>
your-computer: git_project yourusername $ git push

updating 'refs / heads / master'
  from fdbdfe28397738d0d42eaca59c6866a87a0336e2
  to 1c9ec11f757c099680336875b825f817a992333e
 Also local refs / remotes / origin / master
Generating pack ...
Done counting two objects.
Deltifying two objects ...
 100% (2 / 2) done
Writing two objects ...
 100% (2 / 2) done
Total 2 (delta 3), reused 0 (delta 0)
refs / heads / master: fdbdfe28397738d0d42eaca59c6866a87a0336e2 -> 1c9ec11f757c099680336875b825f817a992333e
</ Pre>

All this output basically says that you have your files ready to be pushed (pushed) (Generating pack) and the remote repository has received your files (Writing two objects). Then the remote repository has updated its head / master (the branch "main" repository) to the revision tipped you have committed (commit) by what is known as the last set of changes committed. Now others can update their local copies to be synchronized with the changes you've done. But how are you doing this?
Get updates from afar
To update your local repository and a working copy to the last revision committed to the remote repository, you need to run git pull. This "pulls" all changes from the remote repository and combines them with your current changes (if any).
When you run a git pull, the output should look something like this:

<pre>
remote: Generating pack ...
remote: Done counting 12 objects.
remote: Result has eight objects.
remote: Deltifying 8 objects ...
remote: 100% (8 / 8) done
Unpacking 8 objects ...
remote: Total 8 (delta 4), reused 0 (delta 0)
 100% (8 / 8) done
* Refs / remotes / origin / master: fast forward to branch 'master' of git@yourco.com: git_project
  old .. new: 0c793fd fdbdfe2 ..
Auto-merged file.cpp
Merge made by recursive.
 . Gitignore | 2 + +
 file.cpp | 8 ++++++--
 src / things.html | 5 +++--
 your_file.txt | 18 ++++++++++++++++++
 4 files changed, 19 insertions (+), 4 deletions (-)
 100 644 create mode. gitignore
 100 644 create mode your_file.txt
</ Pre>

What has happened is basically a push in reverse. The remote repository has been prepared and transferred to your local repository changes (Unpacking 8 objects). Your local repository and then making the changes implemented in the same order they were committed (eg combined as the example for file.cpp or creating them as. Gitignore your tu_archivo.txt
Note: The. Gitignore allows you to tell Git to ignore certain files and directories. This option is useful pathings like binary ra generated log files, or also those with local passwords on them.
Branching
You should always create a branch before starting work on a new feature. Thus, the master will always be in a stable state, and you'll have the opportunity to work in isolation from other changes. Creating new branches allows you to take the branch master, "clone", and apply changes to this "cloned." So when you're ready, you can mix your branch with the master, or, if there have been changes to the master while you were working, mix your own branch. It's like pulling and pushing, but everything happens in the same directory. The figure below illustrates the process.
http://hoth.entp.com/output/branching.png

Figure 3: Branching and mixing (merging)

The branching is great for two people to work together on things that require isolation of the main codebase. This could include anything from code that will have permanent results, such as a really big code refactoring or redesign a site, to temporal things, such as performance testing.
Creating a branch (Branch)
To create a Branch in Git, you execute you git checkout - b name> rama>. Any modified file will be listed.

<pre>
$ Git checkout-b redesign
M public / index.html
Switched to a new branch "redesign" 
</ Pre>

Now you've checked the branch redesign. To switch to the master,

<pre>
$ Git checkout master
M public / index.html
Switched to a new branch "master" 
</ Pre>

You'll find very useful to establish the branch in the remote repository, so that others can pull your changes.

<pre>
$ Git push origin redesign
</ Pre>

You can also push your branch to another branch remotely different

<pre>
$ Git push origin redesign: master
</ Pre>

This sets the current working copy to commit and push all changes to branch redesign in local and remote repositories. Now any changes you add and comets live in this branch instead of the master.
Aside: In what branch I am? To view your current branch, and to list all local branches git branch runs
If you need to pull changes from your master branch (ie, major changes in code, security updates, etc) you can do using

<pre>
git pull:
git pull origin
git merge master
</ Pre>

This command tells Git to pull all changes from the repository origin (the name for the repository canonical Git remote) including all branches. Then combine the master branch to yours. When you're ready to combine with the master, you need to check to master, and then combine the branches:

<pre>
git checkout master
git merge redesign
</ Pre>

Now your changes will be combined to the master branch from the branch redesign. If finished with the branch you created, you can delete it using the-d.
git branch-d redesign
To delete the branch in the remote repository, you must capture the push command (remember that you can push a local branch to a remote branch with git push <remote> <local branch>: <remote branch>) and send a local branch empties remote branch.

git push origin: redesign
More useful tools
Undoing your changes
You can remove a file from the staging with git reset HEAD <filename>.
If you want to revert a file to copy in the repository, only Check it again. git checkout <filename>
To revert a file to an older version, use git checkout. Need to know the ID of review, where you can find with git log

<pre>
$ Git log index.html
86429cd28708e22b643593b7081229017b7f0f8d commit
Author: joe <joe@example.com>
Date: Sun February 17 2008 22:19:21 -0800

    build new html files

3607253d20c7a295965f798109f9d4af0fbeedd8 commit
Author: fred <fred@example.com>
Date: Sun February 17 2008 21:32:00 -0500

</ Pre>

    Oops.
To revert the file to the older version (360 725 ...) run checkout. Git draw up the previous version for you, ready for review and commit.
$ Git checkout 3607253d20c7a295965f798109f9d4af0fbeedd8 index.html
If you do not want to restore this old version, you can go back again.

<pre>
$ Git reset HEAD index.html
$ Git checkout index.html
Or in a command
$ Git checkout HEAD index.html
</ Pre>

Have you noticed that is interchangeable with the HEAD revision number? This is so because git, revisions and branches are effectively the same thing.
Who wrote that line?
Run git blame <file> to see who last changed the file and when.
View the full tree
You can view a detailed history of your working copy with gitk.
http://hoth.entp.com/output/gitk.png

Figure 4: Sample gitk screenshot
 Gitk application allows you to navigate through the tree of changes, see diffs, find old reviews and more.
Best practices
We think we can pass this section with a few hints and tips that can help when working with version control systems.
Commits (commit) often
Like when people always say "records often or you'll regret" when trabajs with word processors, you should commit to your local repository as often as possible. Not only protects you from the possibility of losing your job (should not happen if you follow the prime piece of this notice), but will give you security that you can go back anytime you need it. Of course, of course, commit Committing Every after-commit or commit wocommitrd lcommitecommittcommittcommitecommitrcommit could be a bit excessive. At each step you make to your work, you should commit. you take in your work, you should commit.
Throw often
Conversely, you should throw often. Shooting often keeps your code up to date and, hopefully, eliminate the possibility of duplicating work. It is always frustrating when you spend hours working on a property and your colleague and implemented and pushed to the repository, but did not know because it strips every three weeks.
Use checkout and carefully reset
To reverse any local changes you've made to a specific file from your last commit, you can use git checkout <filename>, or also use git reset to kill all changes since your last commit. Having the ability to back steps back is a great tool (especially if you realize that you follow a path completely wrong), but it's definitely a double-edged sword. Once the changes were, they were, so beware!. It's terrible when you realize you threw overboard a few hours of work for a reset of no return.
Create your own repository anywhere.
If you have some control simpre versions in a local project (eg, has a great remote repository or similar), then you can simply use git init to create your own local repository. For example, if you're working on some design concepts of an application, then you could do something like this:
mkdir design_concepts
git init
Now you can add files, commit, branch, and so, as in a remote Git repository "real." If you want to push and pull, you need to configure a remote repository.

I advise you to write setings in the "essay" http://custom-essay-writing-service.org/index.php and "safety Cover" http://www.cheappoolproducts.com.

<pre>
git remote add <alias> <url>
<alias> master git pull
</ Pre>

Artículos

Wed, 14 Jul 2010 11:15:43 Z

Contenido

manifiesto
Artículos
Preguntas frecuentes
Recursos RoR
Noticias
Descargas
Sandbox
Sitio oficial de ruby

Suscribirse a rubylit

Visitar el grupo

Varios

Rest
Anotaciones on rails
Recursos RoR
Ruby GTK
Ruby wxWindows
Tutorial de RubyGame
Nginx+Mongrel_cluster
tasks
tipsEmacs
SetearEncodingConRails
TestConSeleniumOnRails
El problema de recorrer el tablero de ajedrez en 64 movimientos con un caballo
Jaque Mate en dos jugadas
Colocar 8 damas en un tablero de ajedrez sin que se amenacen
Usando Mysql
Usando PostgreSQL
Usando Git
Shebang: Esos caracteres raros al comienzo de un script
Ruby Karel: Es una versión en ruby del clásico programa Karel the Robot

GUI

fxRuby
qtRuby
Ruby/FLTK
ruby-gnome2
ruby/TK
wxRuby
writing help
Shoes

Grupos de Ruby en el mundo

lista en rubygarden.org

tasks

Sat, 19 Jun 2010 08:36:20 Z

The Daunting Task of Outlining Your Research Paper

To explain the plan effective, this failure may be difficult to research and write, and to overcome the production can learn all the research and written communication.

In addition, another type of education or training need to write a research task, their goals, must be considered as a set of essays. To a considerable extent in the nature of these essays, each written, pointing to other parts of the essay, and another to communicate with others you need to.

Your research is a type of company, it will be developed for broader scientific community. You effectively, the structure of work, I think in many parts of the works to attract readers.

Introduction

Section, including, in writing, to discuss regional preparations, including several sections that are connected to the data analysis for the study of the reader. To you, to scientific research in this section, the whole process, so that you can concentrate, and you can specify a first review of the literature to support the establishment of the research. They also included talk of the procedures used to be achieved in this study.

Body

This document includes several parts. A lot of research, data collection work will be mainly used for the “here and often include a chapter on methodology to create the method. This data is analyzed to include all the information, to some, the table has been collected, will be presented in the form of graphs and tables. In addition, read this section provides a summary of the evidence as a whole do research. As a general rule , the paper includes a proposal to support the data analysis.

Conclusion

The last part of the survey, the final document is expected to be completed. This is usually a single chapter and to collect all of the research process. This is a fast-evolving and learning how to include the opinions of the authors of the analysis includes the findings and recommendations for further work in specific subject matter.

After this, effectively, both to understand, more importantly, the research plan, the reader. Each chapter, as well as short as possible, and promote the account to ensure that it is different, in order to maintain the middle on a particular topic. Nobody wants to see more, even if the truth is, if you are repeatedly contrast, comes from a reader would be confused.

Recommended Sites

This difference in nature appears not only between the faculty of knowledge, the faculty of desire and the feeling of pleasure and pain, but also between the Printplace Discount Coupon faculties as sources of representations. Modifications in the English translation used are indicated with an asterisk.

Sandbox

Sat, 12 Jun 2010 15:54:33 Z

Nueva forma de subir una imagen:

[[file name here:file]]

luego para mostrarla:

<img src="files/file name here"/>

prueba al 15/07/2008, funciona subir imagenes al wiki de rubylit?? no hay que poner la extención en el nombre del archivo
test

prueba al 20/07/2008

Esto funciona así:
hay que acceder a esta página para subir archivos.

http://www.rubylit.com.ar/wiki/files/

el problema es que no se especificó el nombre del archivo, entonces si ud quiere subir por ejemplo foo.bar.tgz tiene que escribir lo siguiente:

http://www.rubylit.com.ar/wiki/files/foo.bar.tgz

acá esta como quedaría, va sin la extensión:

Ver explicación en inglés:

http://www.instiki.org/show/FileUploads

para subir un archivo se debe seguir el siguiente procedimiento:

ingrese el siguiente código

click en el link edit de la página.

ingrese el siguiente código. Esto le permitira a usted subir el archivo:

[[nombre_del_archivo.jpg|descripcion:pic]] para subir una imagen.
[[nombre_del_archivo.pdf|descripcion:file]] para subir un archivo. (no está limitado a pdfs).

Envie la pagina.

COLORES*
verde
azul
amarillo
rojo
rosado

Ruby Glade

Instalar Ruby Gtk

Instalar Ruby/Gtk

Version de GTK

Tutorial de Git

Probando un link

titulo con h1

titulo con h2

titulo con h3

titulo con h4

titulo con h5

titulo con h6

h7. titulo con h7

Para llamar al debugger use:

$ ruby -r debug ...

esto es una prueba de construccion de tablas, para escapar el caracter pipe hay que usar <nowiki>|</nowiki>

Para usar el debugger:

b[reak] [file: \| class:]
b[reak] [class.]	set breakpoint to some position
wat[ch] expression	set watchpoint to some expression
cat[ch] exception	set catchpoint to an exception
b[reak]	list breakpoints
cat[ch]	show catchpoint
del[ete][ nnn]	delete some or all breakpoints
disp[lay] expression	add expression into display expression list
undisp[lay][ nnn]	delete one particular or all display expressions
c[ont]	run until essay program ends or hit breakpoint
s[tep][ nnn]	step (into methods) one line or till line nnn
n[ext][ nnn]	go over one line or till line nnn
w[here]	display frames
f[rame]	alias for where
l[ist][ (-\|nn-mm)]	list program, – lists backwards nn-mm lists given lines

<!—
probando comentar un texto
—>

file_name_here

Home Page

Sat, 12 Jun 2010 15:53:52 Z

Contenido

manifiesto
Artículos
Preguntas frecuentes
Recursos RoR
Noticias
Descargas
Sandbox
Sitio oficial de ruby

Suscribirse a rubylit

Visitar el grupo

>> puts “Bienvenido a Rubylit – Ruby y Rails en el litoral”

Acts_as_rubylit_was_a_success

Relizada la jornada prevista para los dia 4 y 5, y habíendo sido todo un exito… como aperitivo a los video y detalles de las charlas desarrolladas…disfruten de estas fotos del evento.

También pueden descargar los videos de las charlas:

Viernes 04/12/2009:

César Ballardini – El modelo de objetos de ruby: reflexiones sobre la reflexión.

Rodolfo Schonhals – Introducción a Rake

Gastón Ramos – Ruby, un lenguaje simple natural y productivo

Link Building

Juan Pablo Taulamet – Introducción a Ruby On Rails – GeneRailsLidades

Sábado 05/12/2009

Gustavo Courault – Como migrar de Clip a Rails

Emilio Tagua – Camino a Rails 3, Integrando Arel
en Active Record

Adrián Mugnolo – Programación concurrente en
Ruby

Pedro Visintin – Desarrollando web 2.0 con ruby y
rails

Acts as rubylit

¿Quiénes somos?

Somos una comunidad de desarrolladores Ruby y Ruby on rails en la región del litoral.

¿Cómo puedo participar?

Tenés que suscribirte a nuestro grupo en google groups

Reuniones:

Próxima Reunión: 05/12/2009

Última Reunión 27/11/2008

Estamos creando nuestro logo

Estamos pensando en organizar una proyeccion de videos y charlas breves

Useful links
editing essay for students.
essays written by professionals.

Reuniones

Thu, 06 May 2010 21:38:08 Z

Reuniones:

Sábado 28/11/2009 FIQ

Jueves 27/11/2008 Puerto Café

29/09/2007 FICH

Anonymous Coward

Tue, 27 Apr 2010 13:13:09 Z

Text View

Thu, 18 Mar 2010 11:41:11 Z

University Level Essay Topics

Most students learn early on that being in university is a lot different from secondary school. For one, the coursework tasks are heavier and more frequently given. For another, the scope and amount of research needed to complete these tasks are greater and more comprehensive. One particular example of this significant gap is in essay writing. University essays require a more formal, in-depth, and intelligent presentation of facts and arguments. Also, typical university essay topics are formulated to test the student’s analytical skills in comprehending what exactly the topic is all about.

Tutors purposely assign topics which has a broader scope or a generalised subject. This is especially true for end-of-term research papers where the objective is how much a student has understood the essential points of the subject. The students are then left to make their own interpretation of the assigned topic, pick out the critical points, then narrow it down to make it more concise. This has been a common complaint of university students who, having no idea of the real intent of the assigned topic, argue that it would take them a lot of time to finish researching for the topic. This is often the result of a poorly understood essay topic. On the other hand, proper analysis of a given topic would result to a much easier identification of materials and information needed thus considerably cutting research time.

Arrows

Fri, 19 Feb 2010 19:33:44 Z

El control Arrow (Flecha) dibuja la cabeza de una flecha, apuntando a un número de direcciones posibles y con un número de estilos posibles. Puede ser muy útil en un botón en muchas aplicaciones. Al igual que el control Label (Etiqueta), tampoco emite ninguna señal.

Para usar el widget tenemos que hacer una llamada al metodo new de Arrow de la siguiente forma.


flecha = Gtk::Arrow.new(arrow_type, shadow_type)

Los tipos posibles (arrow_type) hay que setearlos usando las siguientes constantes

Gtk::Arrow::LEFT
Gtk::Arrow::RIGHT
Gtk::Arrow::UP
Gtk::Arrow::DOWN

En cuanto a las sombras (shadow_type) los tipos posibles son

Gtk::SHADOW_IN
Gtk::SHADOW_OUT   # valor predeterminado
Gtk::SHADOW_ETCHED_IN
Gtk::SHADOW_ETCHED_OUT

joke: le pago un café|cerveza al primero que encuentre las diferencia entre los tipos de sombra. (yo no encontré ninguna)

El siguiente programita muestra un uso posible (en botones) debe notarse que no se definieron señales para los botones, por lo tanto el programa no hace nada.cv writing


require 'gtk2'

class Mi_app < Gtk::VBox
    def initialize()
        super()
        flecha1 = Gtk::Arrow.new(Gtk::Arrow::LEFT, Gtk::SHADOW_ETCHED_IN)
        flecha2 = Gtk::Arrow.new(Gtk::Arrow::RIGHT, Gtk::SHADOW_ETCHED_IN)
        flecha3 = Gtk::Arrow.new(Gtk::Arrow::UP, Gtk::SHADOW_ETCHED_IN)
        flecha4 = Gtk::Arrow.new(Gtk::Arrow::DOWN, Gtk::SHADOW_ETCHED_IN)

        bt1 = Gtk::Button.new()
        bt2 = Gtk::Button.new()
        bt3 = Gtk::Button.new()
        bt4 = Gtk::Button.new()

        bt1.add(flecha1)
        bt2.add(flecha2)
        bt3.add(flecha3)
        bt4.add(flecha4)

        caja = Gtk::HBox.new(false, 25)
        caja.pack_start( bt1, false, false, 3)
        caja.pack_start( bt2, false, false, 3)
        caja.pack_start( bt3, false, false, 3)
        caja.pack_start( bt4, false, false, 3)

        pack_start( caja, false, false, 3)

    end
end

if $0 == __FILE__
    class Viewer < Gtk::Window
        def initialize()
            super()
            set_title("Flechas") 
            set_window_position(Gtk::Window::POS_CENTER)
            signal_connect("delete_event") { |i,a| Gtk::main_quit }
            set_default_size(300, 150)
            add(Mi_app.new)
        end
    end

    Gtk.init()

    view = Viewer.new
    view.show_all

    Gtk.main()
end

HScale y VScale

Fri, 19 Feb 2010 19:32:48 Z

El siguiente ejemplo muestra el uso de los Widget HScale y VScale.


require 'gtk2'

class Mi_app < Gtk::VBox
    def initialize()
        super()
        omogeneus=false
        # Creo una tabla de 2 x 2
        tabla = Gtk::Table.new( 2, 2, true )

        # creo los scales
        horizontal = Gtk::HScale.new(1, 10, 1)
        vertical   = Gtk::VScale.new(1, 10, 1)

        # pongo la tabla en la caja vertical
        pack_start(tabla, true, true, 2)

        # pongo el scale horizontal en la primer columna segunda fila
        tabla.attach(horizontal, 0, 2, 1, 2)

        # pongo el scale vertical en la segunda columna primera fila
        tabla.attach(vertical, 1, 2, 0, 1)

        bt1 = Gtk::Button.new("Clic")
        bt1.signal_connect( "button_press_event", Gdk::Event::BUTTON_PRESS ) do
            print "H:#{horizontal.value}  V:#{vertical.value}\n" 
        end
        tabla.attach(bt1, 0, 1, 0, 1)
    end
end

class Viewer < Gtk::Window
  def initialize()
    super()
    set_title("App Base") 
    set_window_position(Gtk::Window::POS_CENTER)
    signal_connect("delete_event") { |i,a| Gtk::main_quit }
    set_default_size( 300, 300 )
    add(Mi_app.new)
  end
end

Gtk.init()

view = Viewer.new
view.show_all
[ ]

Gtk.main()

nuestro logo

Fri, 19 Feb 2010 14:03:24 Z

Estamos creando nuestro logo al menos para una remera etc. así, estamos buscando a través de essays online.

Logos propuestos
1) Idea: Un Mate de ruby.

Mate ruby gif
Mate ruby gif transp

1.1) Otro mate para Juan Pablo

Otra misma idea otra vista

2) Idea: Un hornero con el rubi como hogar. (supongo que esta un poco grande y hay que retocarla ) :P

v0.2

3) Propuesta de sergio at eim esc edu ar

Mi Sra hizo este logo para Lugmen, pero se está por cambiar por un cóndor, mas representativo de Mendoza, así que queda libre. Es un huron, bicho que aunque no parezca, existe en Argentina, pero se asegura bien de no dejarse ver.

Si lo quieren, está disponible. Solo necesita llevar en la remera un ruby, o ponerle un gorrito de maquinista (x rails)

http://www.lugmen.org.ar/~mabeett/huron_propuesta/lowres/huron1.jpg
resume help

Recursos Ro R

Thu, 04 Feb 2010 09:11:34 Z

Contenido

manifiesto
Artículos
Preguntas frecuentes
Recursos RoR
Noticias
Descargas
Sandbox
Sitio oficial de ruby

Suscribirse a rubylit

Visitar el grupo

Ruby y Rails en Argentina

Grupo Ruby Argentina
Argentina On Rails
Wiki Argentina On Rails

Libros

Deploying Rails Applications

Agile Web Development with Rails

Rails Recipes

Ruby for Rails

Screencasts

Railscasts

Producción

Mongrel

Tutoriales

Emacs como IDE para Rails

custom writing

Varios

Ruby on Rails Cheat Sheet

Enlaces

Ruby Inside

Probando Texto

Thu, 28 Jan 2010 06:23:22 Z

Para mi dissertation puedo utilizar diferentes recursos.

primer reunión

Mon, 07 Dec 2009 08:47:32 Z

Could not include menu
Para poder establecer en principio el lugar y a continuación la fecha, decidimos anotarnos, para ver cuantos seríamos agrupándonos por localidad.

La propuesta de Gastón fue:

”...Hola gente estaba pensando en ir organizando una primer renuión algo simple, y quizás hacer unas mini charlas para nosotros, ‘pelar’ la nootebook y mostrar algunas cosas en la que estamos c/u no más que eso…”

Que día es la reunión?

29/09/2007

Dónde es?

Aula Magna Facultad de Ingeniería y Ciencias Hídricas FICH - Ciudad Universitaria – Paraje el Pozo – Santa Fe

Lugar

Aula Magna

Mapas

Acceso a la Ciudad Universitaria

A qué hora?

10hs.

Afiches para descargar

Png:
1er-reunion-rubylit.png
1er-reunion-rubylit.png.gz

Fuente Gimp:
1er-reunion-rubylit.xcf.gz

Quienes vamos hasta ahora?

Total = 11 y contando :)

Santa Fe = 5 : Gastón Ramos, Juan Pablo Taulamet, Fornal Esteban, Cesar Diaz, Federico Díaz,
Paraná = 0 :
Rosario = 1: Matías Piuma,
Buenos Aires = 1: Rafael Bidegain,
Oro Verde = 2: Juan Giménez Silva, Germán Giménez Silva
Corrientes = 1: Jose Alfredo Ramirez
C. del Uruguay = 1 : Gabriel Arellano

Charlas:

Hora	Charla	Orador/es
10:30 hs	Desarrollo web ágil sobre rieles	Esteban y Gaston
12:30 hs	Descanso para comer (La cantina estará abierta :)
13:30 hs	Active Record, sabor Ruby	Gaston
15:00 hs	Librerías en Ruby, haciendo uso de Mysql, Gd, Ncurses y Qt4	Germán

acts_as_rubylit

Fri, 04 Dec 2009 22:29:01 Z

Acts_as_rubylit 04/12 y 05/12 en la FICH.

Tenemos el agrado de anunciar un evento plenamente rubista en el litoral argentino, al que hemos denominado acts_as_rubylit, el cual se llevará a cabo en la Facultad de Ingeniería y Ciencias Hídricas, Universidad Nacional del Litoral de la ciudad de Santa Fe.
La intención del grupo es acercar a la comunidad académica y en general el lenguaje Ruby en sus diferentes sabores y colores, con casos prácticos y conscisos que irán desde el nivel básico al avanzado.
Contaremos con la presencia de profesionales muy conocidos y respetados dentro del ambiente Ruby en el país, quienes compartirán sus experiencias, consejos y descubrimientos con el público en general.

Inscripción

Charlas confirmadas

viernes 04/12/2009

17:00 hs. César Ballardini: El modelo de objetos de ruby: reflexiones sobre la reflexión.
18:00 hs. Rodolfo Schonhals: Introducción a Rake.
19:00 hs. Gastón Ramos: Ruby, un lenguaje simple natural y productivo.
20:00 hs. Juan Pablo Taulamet: Introducción a Ruby On Rails – Gene Rails Lidades?.

sábado 05/12/2009

09:00 hs. Gustavo Courault: Como migrar de Clip a Rails.
10:00 hs. Emilio Tagua: Camino a Rails 3 – Integrando Arel en Active Record.
11:00 hs. Adrián Mugnolo: Programación concurrente en Ruby: procesos, hilos y fibras.
12:00 hs. Pedro Visintin: Desarrollando web 2.0 con ruby y rails. Mitos y Verdades

Otras Actividades (A confirmar)

Lightings talks

La idea en sintesis es generar un espacio de desarrollo y programación con Ruby y algunos de los frameworks más usados, como ser Rails, Sinatra u otros (no digamos Merb porque va a ser parte de Rails 3), amén de un installfest, de ser posible.

Call for charlas (cerrado)

Rubylit – Grupo de Rubystas del Litoral
(http://www.rubylit.com.ar), llama a la participación de la comunidad de
Ruby a las Primeras Jornadas de Ruby del litoral argentino, a realizarse en la ciudad de Santa Fe los días viernes 4 y Sábado 5 de diciembre.

Agradecemos la contribución de todos en la difusión de este llamado y del evento. Las charlas fueron recibidas hasta el Sábado 21 de noviembre de 2009 inclusive y en este momento el llamado se encuentra cerrado.

Información acerca de hospedaje en Santa Fe

Hotel Brigadier SH
Dirección: San Luis 2148
Teléfono: 0342 – 4537387

Costo por persona:
$100 incluyendo desayuno

Reserva: aconseja llamar una semana antes para la reserva y si alguien deja algún porcentaje del costo como seña mejor.

Hotel Suipacha
Dirección: Suipacha 2375
Teléfono: 0342 – 4521135

Tarifas por habitación para:
4 personas $210
3 personas $180
2 personas $130
1 persona $90

Servicios: desayuno , tv.

En el mapa.

Reserva: llamar preferentemente entre 4 o 5 días de anticipación. Dejar seña de la reserva

Hotel España
Dirección: 25 de Mayo 2676
Teléfono: 0342 – 4008834

Para mas información sobre tarifas ir a la pagina web
http://www.lineaverdedehoteles.com.ar/sitio/espanatarifas.html

En el mapa

Hotel Conquistador
Dirección: 25 de Mayo 2676
Teléfono: 0342 – 4001195

Para mas información sobre tarifas ir a la pagina web
http://www.lineaverdedehoteles.com.ar/sitio/conquistadortarifas.html

Hotel Bertaina
Dirección: H Irigoyen 2255
Teléfonos: 0342 – 4532287/4553068

Tarifas por habitación para:
4 personas $260 (1 cama matrimonial y dos simples)
3 personas $210
2 personas $180
Habitación individual $120

Reserva: llamar una semana y media antes en lo posible

Hotel Corrientes
Dirección: Corrientes 2520
Teléfono: 0342 – 4592126

Servicios: desayuno, tv y cochera

Tarifas por habitación para:
4 personas $440
3 personas $360
2 personas $240
Habitación individual $170

Reserva: hacer la reserva en lo posible una semana antes

Para mas información sobre tarifas ir a la pagina web
http://www.hotelcorrientes-sf.com.ar

Hotel Hernandarias
Dirección: Rivadavia 2680
Teléfono: 0342 – 453-8188

Para mas información sobre tarifas ir a la pagina web
aquí

RubyLit - Ruby.del.litoral!

Tutorial de Git

Artículos

Contenido

Varios

GUI

Grupos de Ruby en el mundo

tasks

Sandbox

titulo con h1

titulo con h2

titulo con h3

titulo con h4

titulo con h5

titulo con h6

Home Page

Contenido

Acts_as_rubylit_was_a_success

También pueden descargar los videos de las charlas:

Viernes 04/12/2009:

Sábado 05/12/2009

Acts as rubylit

¿Quiénes somos?

¿Cómo puedo participar?

Reuniones:

Estamos creando nuestro logo

Estamos pensando en organizar una proyeccion de videos y charlas breves

Useful linksediting essay for students.essays written by professionals.

Reuniones

Reuniones:

Anonymous Coward

Text View

Arrows

HScale y VScale

nuestro logo

Recursos Ro R

Contenido

Ruby y Rails en Argentina

Libros

Screencasts

Producción

Tutoriales

Varios

Enlaces

Probando Texto

primer reunión

La propuesta de Gastón fue:

Que día es la reunión?

Dónde es?

Lugar

Mapas

A qué hora?

Afiches para descargar

Quienes vamos hasta ahora?

Charlas:

acts_as_rubylit

Acts_as_rubylit 04/12 y 05/12 en la FICH.

Inscripción

Charlas confirmadas

Call for charlas (cerrado)

Useful links
editing essay for students.
essays written by professionals.