IntelliJ IDEA and their Ruby plugin.
···
--
Alex Verkhovsky
"Kyle Schmitt" <kyleaschmitt@gmail.com> wrote in message
news:2b548b8b0704120947y1b1eef3bld9fc00d916c0599@mail.gmail.com...
Interestingly the SciTE webpage shows intellisense type stuff for
python and other languages. I wonder how to get that working in
ruby...
We already have IntelliSense (I don't mean just 'code completion' but real
analytical IntelliSense that knows about class ancestry, scope, mixins,
singletons, etc.) in Ruby In Steel Developer. In answer to your question on
how to get that working in Ruby: it's very, very difficult. We had to write
what amounts to a background Ruby interpreter to analyse code as it is being
entered. Suffice to say, it wasn't a trivial undertaking 
You might like to watch our short screencast for a simple demo:
http://www.sapphiresteel.com/Ruby-In-Steel-Movies
Some more info here: http://www.sapphiresteel.com/IntelliSense
best wishes
Huw Collingbourne
http://www.sapphiresteel.com
Ruby Programming In Visual Studio 2005
Hello all,
A journey that has taken me from developing in Filemaker through the self study of Ruby, Rails, and regular expressions has led me to begin looking at algorithms and data structures. Though I don't have a traditional computer science background, I am trying to educate myself as best I can.
I am begin stymied by what looks like math but is greek to me. For example, on the first page of the book I am reading (The Algorithm Design Manual, b Steven Skinea), there is this description of the insertion sort algorithm:
for i = 1 to n - 1 do
for j = i downto 2 do
if (A[j] < A[j-1]) then swap(A[j],A[j-1])
I can struggle through it, but I am wondering 1) what branch of math is this? Is it algebra or something more complex? And 2) are there any good (and accessible) books that will give me a basic introduction to the language conventions?
Thanks so much,
Don Levan
Brooklyn, New York
who can tell me how to close vim-ruby plugins' auto-complete?
when i type <C-p> in insert mode,it always search the whole .rb files
in ruby lib folder,
and it's slow...
thanks
cy
···
2007/4/13, John Mettraux <jmettraux@openwfe.org>:
2007/4/13, Brian Adkins <lojicdotcomNOSPAM@gmail.com>:
>
> > So what IDE do you prefer in order to code and to debug ruby?
>
> vim/gvimme too, with the "commonsense" (tm) technology included.
--
John Mettraux -///- http://jmettraux.openwfe.org
Vlad Ciubotariu wrote:
> Is anyone using Activestate's Kodomo? I know activestate is a player in
> the perl community but I don't know much about the ruby world.
<snip....>
I'm using Komodo and I like it. I did a rather lengthy evaluation, and
<snip ..>
or a desktop other than KDE, you have a fair amount of work to do.
Komodo runs on at least Windows and Linux, is toolkit neutral (but
prefers Tk / ActiveTcl), and has a pretty good Ruby interface. >
Komodo runs just as well on a Mac. One price for three platforms is
pretty hard to beat. The edit-time syntax checking has saved me
countless hours in Ruby and Javascript. I'm also running Steel on
Windows Visual Studio 2005 but the free version does not have
intellisense so who knows. And of course you have to buy MS VS 2005
(the express free version does not support Steel).
I rarely use the debugger in Komodo but it's there if I need it. The
interactive Ruby shell in Komodo does not work as well as irb.
I use Vim and bash all the time and I am confident that they do not
constitute an IDE despite arguments to the contrary in this forum.
Bob
···
On Apr 12, 11:14 pm, "M. Edward (Ed) Borasky" <z...@cesmail.net> wrote:
It's strange. When I developed in Java, I used the Eclipse debugger a lot
- it's really quite good. I keep thinking I'll get around to setting up a
nice debugger environment for Ruby, but it just hasn't been an issue yet.
It would be nice to be able to debug from within vim, but it's not as big
of a need as it was with Java for some reason.
···
On Fri, 13 Apr 2007 16:28:18 +0900, Martin Krauskopf wrote:
Brian Adkins wrote:
On Thu, 12 Apr 2007 03:54:49 -0700, ChrisKaelin wrote:
[...]
So what IDE do you prefer in order to code and to debug ruby?vim/gvim
I'm just curious whether Vim supports Ruby debugging? I've googled out
just some information about "How it would be technically possible". But
not any working implementation. So is there any?Thanks,
m.
Actually, the blog states that there is one in the works:
Last sentence.
Regards,
Florian Gilcher
···
On Apr 22, 2008, at 4:33 PM, Zundra Daniel wrote:
I agree e text editor is great. I just wish there was a Linux version.
On Fri, Apr 18, 2008 at 4:42 AM, arjun ghosh <arjun4ruby@gmail.com> > wrote:
have u tried using e-texteditor. It is like textmate but for windows. cool
for ruby codingOn Thu, Apr 12, 2007 at 3:55 AM, ChrisKaelin <ck.stonedragon@gmail.com >> > >> wrote:
I prefer using eclipse for it's freedom, ruby and svn plugins etc. But
the big problem now is, debuggin does not work anymore after v. 3.2
and a solution seems to be quite some time away and rdb is a little
unhandy for a lazy type like me...So what IDE do you prefer in order to code and to debug ruby?
TextMate by far.
···
--
Jeremy Tregunna
jtregunna@blurgle.ca
On 12-Apr-07, at 11:34 AM, Alexey Verkhovsky wrote:
IntelliJ IDEA and their Ruby plugin.
--
Alex Verkhovsky!DSPAM:461e5114472091617968907!
Yeah, intellij for me too
···
On 4/12/07 11:34 AM, "Alexey Verkhovsky" <alexey.verkhovsky@gmail.com> wrote:
IntelliJ IDEA and their Ruby plugin.
--
Alex Verkhovsky
Hi,
Haven't tried it yet, but I read on a blog about Eclipse DLTK. They've got IntelliSense working for Ruby in Eclipse. So this means free cross-platform IntelliSense! A screencast can be found here:
http://us.xored.com/~haiodo/EclipseCon07/dltk-ruby.mov
Regards,
Peter
Sorting algorithms are typically covered in college computer science
classes with titles like "Data Structures & Algorithms". Sorting is a
CS topic and it doesn't appear to be studied in many math
departments... but some "Discrete Math/Number Theory" kinds of courses
might cover related topics. Donald Knuth has a set of books called
"The Art of Computer Programming" that are very good for learning all
kinds of algorithms and how to apply them. I think Volume 3 deals
specifically with sorts/sieves.
···
On 4/13/07, Don Levan <levandon@gmail.com> wrote:
Hello all,
A journey that has taken me from developing in Filemaker through the
self study of Ruby, Rails, and regular expressions has led me to
begin looking at algorithms and data structures. Though I don't have
a traditional computer science background, I am trying to educate
myself as best I can.I am begin stymied by what looks like math but is greek to me. For
example, on the first page of the book I am reading (The Algorithm
Design Manual, b Steven Skinea), there is this description of the
insertion sort algorithm:for i = 1 to n - 1 do
for j = i downto 2 do
if (A[j] < A[j-1]) then swap(A[j],A[j-1])I can struggle through it, but I am wondering 1) what branch of math
is this? Is it algebra or something more complex? And 2) are there
any good (and accessible) books that will give me a basic
introduction to the language conventions?Thanks so much,
Don Levan
Brooklyn, New York
This is not math, but pseudocode, it is different in just about any
book about algorithms.
The Algorithm Design Manual is probably not a very good book to start
with, short explanations and lots of mathematical notations. Try to
find a more accessible book if you don't understand things. An
alternative is just to use google and wikipedia a lot, there are a lot
of free resources.
···
On 4/13/07, Don Levan <levandon@gmail.com> wrote:
Hello all,
I am begin stymied by what looks like math but is greek to me. For
example, on the first page of the book I am reading (The Algorithm
Design Manual, b Steven Skinea), there is this description of the
insertion sort algorithm:for i = 1 to n - 1 do
for j = i downto 2 do
if (A[j] < A[j-1]) then swap(A[j],A[j-1])I can struggle through it, but I am wondering 1) what branch of math
is this? Is it algebra or something more complex? And 2) are there
any good (and accessible) books that will give me a basic
introduction to the language conventions?
I use Kate on Linux, and Notepad++ in Windows.
I've tried the Ruby plugin for Eclipse and I found it has a long way to go.
···
On 13/04/07, yang cao <caoyangruby@gmail.com> wrote:
who can tell me how to close vim-ruby plugins' auto-complete?
when i type <C-p> in insert mode,it always search the whole .rb files
in ruby lib folder,
and it's slow...thanks
cy2007/4/13, John Mettraux <jmettraux@openwfe.org>:
> 2007/4/13, Brian Adkins <lojicdotcomNOSPAM@gmail.com>:
> >
> > > So what IDE do you prefer in order to code and to debug ruby?
> >
> > vim/gvim
>
> me too, with the "commonsense" (tm) technology included.
>
> --
> John Mettraux -///- http://jmettraux.openwfe.org
>
<bgulian@gmail.com> wrote in message
news:1176471246.813110.141230@q75g2000hsh.googlegroups.com...
I'm also running Steel on
Windows Visual Studio 2005 but the free version does not have
intellisense so who knows.
The 30 day Trial of Ruby In Steel Developer has IntelliSense - not to
mention the fast debugger
Download the Trial here: http://www.sapphiresteel.com/steelworks/
best wishes
Huw Collingbourne
http://www.sapphiresteel.com
Ruby Programming In Visual Studio 2005
bgulian@gmail.com wrote:
The
interactive Ruby shell in Komodo does not work as well as irb.
I mentioned that on the Komodo beta mailing list. The way they have the shells set up makes it difficult but not impossible to interface with "irb", but their developers are looking for a way to do it -- they know Rubyists can't live without the look and feel of irb. I'm not that sort of hacker, or I'd take a shot at it. What little Komodo hacking time I have I was planning on spending doing a lexer for the R language. 
I use Vim and bash all the time and I am confident that they do not
constitute an IDE despite arguments to the contrary in this forum.
Emacs is closer than Vim, and Vim is gaining on Emacs, but yes, neither constitutes a true IDE. I think I could make a case for the Linux desktop as an IDE, however.
···
--
M. Edward (Ed) Borasky, FBG, AB, PTA, PGS, MS, MNLP, NST, ACMC(P)
http://borasky-research.net/
If God had meant for carrots to be eaten cooked, He would have given rabbits fire.
Don,
Actually there is just a bit of math there, but none of it is complex at
all, at least in the conceptual realm.
What you are looking at is a bit of pseudo-code. It's not actually any
specific language but borrows common bits from many such as:
iteration (for loops in this case)
indexing (that's the A[j] notation you see, as it refers to the jth element
of an array called A,
conditional statements (if (something is true) then (do something)
comparison (in this case comparing adjacent array elements: A[j] and A[j-1])
function calls ( swap(Array element 1, Array element 2) is a particularly
bad example but it communicates the idea of swapping the position of two
elements in an array based on a comparison)
As you get into your book you'd actually find out that from a design stand
point you're most interested in the looping structure of that code, since
being able to predict how many times the code has to do the comparison and
swap operations will till you how expensive it is in computer cycles.
My advice is: don't worry about the pseudo-code as long as you can
understand how it uses the basic concepts such as those listed above. More
important is being able to translate those concepts into your language of
choice such as Ruby. Ruby would have many many ways of doing an insertion
sort, and it might be worthwhile to code a couple just for practice.
Also, while the Knuth work is the seminal standard, it's not at all easy to
work with (His code snippets tend to resemble Assembly language), and a more
basic text will give you a better introduction to the material your working
with.
Hope this helps,
Bryan W
···
On 4/12/07, Don Levan <levandon@gmail.com> wrote:
Hello all,
A journey that has taken me from developing in Filemaker through the
self study of Ruby, Rails, and regular expressions has led me to
begin looking at algorithms and data structures. Though I don't have
a traditional computer science background, I am trying to educate
myself as best I can.I am begin stymied by what looks like math but is greek to me. For
example, on the first page of the book I am reading (The Algorithm
Design Manual, b Steven Skinea), there is this description of the
insertion sort algorithm:for i = 1 to n - 1 do
for j = i downto 2 do
if (A[j] < A[j-1]) then swap(A[j],A[j-1])I can struggle through it, but I am wondering 1) what branch of math
is this? Is it algebra or something more complex? And 2) are there
any good (and accessible) books that will give me a basic
introduction to the language conventions?Thanks so much,
Don Levan
Brooklyn, New York
Time to check in...
We're back in another round putting more work into the Ruby
side of Komodo. I just redid the debugger -- it's now built on
top of Kent Sibelev's ruby-debug module (http://rubyforge.org/projects/
ruby-debug/)
and works way faster. About 50 times faster on average.
I'm surprised no one here pointed out how slow the old one was.
Thank you.
As for the code-completion, I haven't been able to check out
Sapphire yet. We got out of the Visual Studio plug-in
game a couple of years ago (http://it.slashdot.org/article.pl?
sid=05/12/15/2112237),
and I haven't bothered to install VS 2005 since then. Full
code-completion is tough, but we try with the same kind of
on-the-fly code analysis Huw was talking about. I have to
admit that the VS API was designed to deliver results very
quickly in response to code changes.
Sorry this is more plug than informative. FWIW I use Komodo,
VS.Net 7.1 for C++ debugging, some emacs, some vi/vim, and
of course cat.
- Eric
Don Levan <levandon@gmail.com> writes:
Hello all,
A journey that has taken me from developing in Filemaker through the
self study of Ruby, Rails, and regular expressions has led me to
begin looking at algorithms and data structures. Though I don't have
a traditional computer science background, I am trying to educate
myself as best I can.I am begin stymied by what looks like math but is greek to me. For
example, on the first page of the book I am reading (The Algorithm
Design Manual, b Steven Skinea), there is this description of the
insertion sort algorithm:for i = 1 to n - 1 do
for j = i downto 2 do
if (A[j] < A[j-1]) then swap(A[j],A[j-1])I can struggle through it, but I am wondering 1) what branch of math
is this? Is it algebra or something more complex? And 2) are there
any good (and accessible) books that will give me a basic
introduction to the language conventions?
Its what is often referred to as 'pseudo code', a sort of generalised
programming language abstraction. There are no real rules and generally only a
few very simple constructs to learn. In the example you give above, possibly
the only two constructs that may need explination are the A[..] and swap(...)
constructs.
Generally, pseudo code is something the author will define themselves and you
will often find an explination of their particular flavor of pseudo code in the
introduction or early chapters of the book. The primary aim of pseudo code is
to describe algorithms in a general an concise manner without getting bogged
down in the syntax associated with real code. There are some basic conventions
for pseudo code, but no definite or specific rules.
Pretty much all programming languages have a basic set of things they can do.
Most pseudo code will have some sort of construct to represent these basic
operations. In general, you have notation to represent
- Basic variables and simple data structures such as arrays. You may have a
'struct' or record type as well.
- Some construct to represent value asignment
- Some construct to represent branching/conditional operations, such as 'if'
and 'else'.
- looping constructs, such as 'for', 'while' and 'until'.
- Named code blocks, sometimes done via some sort of 'label' or
function/procedure call.
By convention, variables with names like 'i', 'j', and 'k' are used to
represent counters or index variables. The variable 'n' is often used to
represent the count or size of something.
Generally speaking, constructs like A represent an array. something like A[0]
would represent the first element of the array 'A', where 'A' is the symbol or
name given to the storage location for the array of values. (more often than
not, computer languages start counting from 0 rather than 1). A[j] represents
the element of the array A at position j. A construct like A usually
represents a two dimensional array, which might be used to represent something
like a matrix.
The construct swap() represents what is often referred to as a function or a
procedure. Essentially, it is a named block of code that will perform some
operation. Often, functions are named blocks of code that when executed, will
return some value while procedures are a block of code which will do something,
but may not return any value.
The use of named blocks of code are really an abstraction that allow you to
think at a higher level. For example, in the pseudo code you have, swap(A[j],
A[j-1]). We know by the name that this procedure will 'swap' something. We can
see that it takes two arguments (A[j] and A[j-1]), so we can be fairly
confident that what it is doing is swapping the two values at positions j and
j-1 in the array A. We don't have to think about how it does that operation -
simply assume that it does and afterwards, the two values have been swapped
over. We don't need to think about how this swap operation will also need to
have a temporary 'holding' place that the first value can be stored in while
the second balue is moved form its position into the first position and then
the first value is moved from its temporary position into the second position.
Likewise, we don't have to be concerned about whether the values being operated
on are pointers, copies of the originals global values. We don't have to be
concerned with error handling, data typing etc etc. Instead, we only have to
understand the concept of swapping two values without all the additional
overheads normally encountered in an actual program which implements such an
operation.
The real trick with pseudo code is not to read too much into it. It is meant to
be a high level, but still reasonably concise and unambiguous description of an
algorithm.
When I first started learning this stuff, particularly sorting and searching
algorithms, I found it very handy to have a deck of cards on hand. You could
try it with the pseudo code above and imagine your trying to execute that
pseudo code.
Shuffle the cards to ensure a random order. Then lay out 10 cards face up on
the table. Those 10 cards represent your array 'A'. As there are 10 cards, we
can say that your array has 10 elements, a size of 10. When you get to the
'swap()' operation, just swap the two cards that correspond to the arguments,
which will translate into array positions (i.e. card positions).
Doing this with each of the different sorting algorithms will give you a real
appreciation of why some sorting algorithms are better than others. I suspect
you will find this an extremely useful technique when it comes to less
obvious/intuitive sorting approaches, such as quicksort.
With respect to your question on books, I would recommend going to a good
library and checking out some of the introductory books on discrete maths, data
structures and algorithms. Different styles suit different people and what I
found great you may not. For example, when I did my computing degree, I didn't
particularly like the style of the prescribed text books. I whent to the
library and discovered Donald Knuth and Nicholas Wirth. I found these two
authors really good. For me, their explinations were clear, interesting to read
and sat well with my conceptual model of the world. However, I know others who
cannot stand their work.
Once you find an author or books you like, then try and get copies for
yourself. I highly recommend checking out Donald Knuth. In particular, his
"Concrete Maths for Computing Science" (I think thats what it was called - or
something similar). It is in my view and excellent book. His style is clear and
he has included margin notes from students, which apart from adding additional
insight/background, are often humorous and that always helps. He has also
written an excellent series called "The Art of Computer Programming", but it is
quite 'heavy'. However, as I said, I really like his style and personally got a
lot out of it. There are also some great on-line resources from MIT (they have
put a lot of their course resources on-line now and they are largely free).
Therre is an excellent book called "Structure and Interpretation of Computer
Programs", which can be a bit heavy at times, but is an excellent example of
the power of abstraction and using the right data structures to solve problems.
Possibly its only drawback for many people is that it is based around scheme.
However, you can still get a lot out of it without needing to fully understand
scheme itself. There are also some movies on-line of the authors presenting
courses based on the content of the book.
Finally, don't get too concerned because this stuff looks like maths. In
reality, it is just notation used to describe a discrete set of steps that need
to be followed. The mathematical like notation is used because it is more
concise and less ambiguous than written english.
HTH
Tim
···
--
tcross (at) rapttech dot com dot au
brpreiss.com is worth a look. However, if your
goal is to teach yourself about algorithms and data structures, I'd
suggest working your way through How to Design Programs (download
DrScheme as the recommended scheme implementation), and then proceed
with Structure and Interpretation of Computer Programs, the classic
text on the subject.
martin
···
On 4/13/07, Don Levan <levandon@gmail.com> wrote:
Hello all,
A journey that has taken me from developing in Filemaker through the
self study of Ruby, Rails, and regular expressions has led me to
begin looking at algorithms and data structures. Though I don't have
a traditional computer science background, I am trying to educate
myself as best I can.
Peter C. Verhage wrote:
...
got IntelliSense working for Ruby in Eclipse. So this means free
cross-platform IntelliSense! A screencast can be found here:
...
One note: IntelliSense is simply Microsoft's branding of a host of
features such as code-completion (which is all it was originally in VB
5, then they added more to it later). The term is trademarked by
Microsoft.
I see a lot of people say something like "it is more than code
completion, it's IntelliSense". Many IDEs have similar, or even better,
features than MS does with their IntelliSense. They just can't call it
that for legal reasons.
···
--
Posted via http://www.ruby-forum.com/\.