What is your favourite IDE?

S

Sander Land

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?

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.

http://en.wikipedia.org/wiki/Pseudocode
http://en.wikipedia.org/wiki/Insertion_sort
 
D

Dan Stevens (IAmAI)

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.

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
 
P

Peter C. Verhage

is much more complete than Komodo's. If you have examples of other IDEs
which offer comparable features, we genuinely would like to know. I've just
put online a short article which may help you when evaluating Ruby
IntelliSense. I would honestly be very grateful for any reports on similar
capabilities which you may find in other IDEs.

Well the "auto-completion etc." support in Eclipse DLTK looks to be very
good. So maybe you could compare your product to it.

Regards,

Peter
 
B

bgulian

I'm using Komodo and I like it. I did a rather lengthy evaluation, and
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
 
M

M. Edward (Ed) Borasky

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. :)
 
B

Brian Adkins

Brian said:
[...]
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.

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.
 
A

ara.t.howard

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. :)

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. :)

screen + vim is the best ide ever imho. amazingly, it works for all source
code types ;-)

-a
 
E

Eric Promislow

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
 
M

Martin Krauskopf

Eric said:
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.

Hi Eric,

I'm just curious how did you plug into Kent's ruby-debug? Do you utilize
ruby-debug (cli) directly? Or do you write your own extension to
ruby-debug-base? Somehow utilizing debug-commons project?
Seems that everybody somehow utilizes ruby-debug which is obvious. But
there seems to be a lot of duplication efforts. Just curious :)

Thanks,
m.
 
J

John Joyce

I think one of the real potential benefits of a more sophisticated
IDE is the
ability to move from basic syntax highlighting of code to something
more like
semantic highlighting of code. While syntax highlighting is nice,
syntax is
usually only an issue when first learning a language. Once you have
experience,
help with semantic issues is probably more beneficial.

Tim
If you need semantic highlighting in Ruby code, then you're doing
something wrong semantically. Ruby code should generally be short and
sweet and well organized into lots of files. The code blocks should
be pretty self descriptive. Semantic highlighting defeats the point
of syntax highlighting: the ability to see mistakes by color!
 
H

Huw Collingbourne

Eric Promislow said:
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),

Yes, we noticed that :)
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.

As I said before, Komodo's Ruby code completion is the best I've come across
(other than ours). I am an admirer of Komodo (see my review here:
http://www.bitwisemag.com/2/Komodo-IDE-4) and it is my IDE of choice when
not using Visual Studio. It turns out that, in spite of some overlap, Komodo
and Ruby In Steel are not at all the same types of product. Komodo is
multi-language and multi-platform; Ruby In Steel is one language (Ruby) and
one-platform (Visual Studio). In spite of requests from some people to
'break out' of Visual Studio, this is something we won't be doing. We are
completely focussed on Ruby and Visual Studio.

So far, we have had two main goals: 1) to have the best Ruby IntelliSense
and 2) to have the fastest Ruby debugger. To the best of my knowledge, we
can claim success in both these areas.

But in terms of the breadth of programming features for dynamic languages in
general, we are not in competition with ActiveState. Naturally I hope that
Visual Studio users programming Ruby will use Ruby In Steel. But if you
aren't using VS or if you want to program on other platforms and in other
languages, I would recommend that you use Komodo.

best wishes
Huw Collingbourne

http://www.sapphiresteel.com
Ruby Programming In Visual Studio 2005
 
H

Huw Collingbourne

Can you clarify what you mean by semantic highlighting? I'd be interested to
see a concrete example of Ruby code to show how this might be useful.

As for the ideal that Ruby code should be short and sweet. I am very much of
that opinion too. In fact, however, if you look through many of the widely
used libraries used with Ruby you'll find that this ideal is rarely
achieved. Single methods taking tens or hundreds of lines of code are
commonplace. Contrast the Smalltalk class library (average method length 7
lines).

We are working on some ideas which should assist Ruby programmers to
structure their code into smaller blocks at the moment. Semantic
highlighting has not, thusfar, been an idea we've considered. But if it
seems useful, please help me to understand why ;-)

best wishes
Huw Collingbourne

http://www.sapphiresteel.com
Ruby Programming In Visual Studio 2005
 
M

M. Edward (Ed) Borasky

John said:
If you need semantic highlighting in Ruby code, then you're doing
something wrong semantically. Ruby code should generally be short and
sweet and well organized into lots of files. The code blocks should be
pretty self descriptive. Semantic highlighting defeats the point of
syntax highlighting: the ability to see mistakes by color!
I think we're starting to get into language design and language
processor implementation issues here, and I'm all in favor of debating
that. :) First of all, how many programmers *really* program in only one
language? And how many programmers *really* program on a "team of one?"
I'd venture to guess that the answer to both questions is "almost none".

I've been programming a long time, and there were in fact a number of
times when I was on what were essentially one-person one-language
couple-of-month projects. But the last time I can remember was a FORTRAN
port of a finite element code I did in the late 1980s. Since then,
nearly every programming project I've been part of has involved multiple
programmers and multiple languages. And FORTRAN (77) is probably the
last language I ever used where I could claim with a straight face that
I knew *all* the syntax and semantics.

So that's why there *must* be IDEs. Nobody works *alone* and nobody
knows it *all*. As I've said before, I think I can make a case for the
Linux desktop as an IDE. I have my choice of two mainstream programmers'
editors, vim and emacs, all of the languages (except Visual Basic),
compilers, debuggers, Acroread, "info" and "man" to read the manuals
(since I don't know all the syntax and semantics), SVN, CVS and a few
other version control systems, and many other intra-team communications
tools.

So ... syntactic highlighting? Aside from the two languages with more or
less trivial syntax, Lisp/Scheme and Forth, I find it impossible to live
without syntactic highlighting. I program in at least Perl, Ruby, R and
"bash", plus a couple of obscure things I can't mention here. None of
them have the same syntax. Code completion? Saves me a trip to the
on-line manual! And I'd dearly love to have semantic highlighting! Since
I still tend to think in assembler, I need something to get me up to a
higher level. For example, I'd love an IDE that draws diagrams of my
data structures for me. I'd love to be able to, for example, see a hash
with keys and values right there on the screen.

But what I'd *really* like is a language and an implementation of that
language that *was* an IDE! The closest thing to that I've ever seen is
the intricate entwining of Lisp and Emacs, and that, in a kind of
linear, one-dimensional, "auditory" way, is the core concept. But expand
that -- data structures other than the linked list, two-dimensional and
three-dimensional diagrams, color, stereo sound, animation. And, of
course, it needs to be open source. :)
 
C

Chad Perrin

I've been programming a long time, and there were in fact a number of
times when I was on what were essentially one-person one-language
couple-of-month projects. But the last time I can remember was a FORTRAN
port of a finite element code I did in the late 1980s. Since then,
nearly every programming project I've been part of has involved multiple
programmers and multiple languages. And FORTRAN (77) is probably the
last language I ever used where I could claim with a straight face that
I knew *all* the syntax and semantics.

So that's why there *must* be IDEs. Nobody works *alone* and nobody
knows it *all*. As I've said before, I think I can make a case for the
Linux desktop as an IDE. I have my choice of two mainstream programmers'
editors, vim and emacs, all of the languages (except Visual Basic),
compilers, debuggers, Acroread, "info" and "man" to read the manuals
(since I don't know all the syntax and semantics), SVN, CVS and a few
other version control systems, and many other intra-team communications
tools.

I don't agree that one needs IDEs for multi-language, multi-person
projects, unless (as you say) a free unix OS like Linux qualifies as
an IDE. I've made the statement before that my Debian GNU/Linux machine
(which has since suffered unrecoverable hardware failure -- now I'm
using a FreeBSD machine for the same purposes) was my IDE, but any time
I say that I tend to get people telling me it doesn't count as an IDE.

But what I'd *really* like is a language and an implementation of that
language that *was* an IDE! The closest thing to that I've ever seen is
the intricate entwining of Lisp and Emacs, and that, in a kind of
linear, one-dimensional, "auditory" way, is the core concept. But expand
that -- data structures other than the linked list, two-dimensional and
three-dimensional diagrams, color, stereo sound, animation. And, of
course, it needs to be open source. :)

Isn't that what Smalltalk does? It combines the language and the IDE in
one convenient package. I'm sure I've seen a couple other languages do
the same sort of thing, but at the moment I'm drawing a blank on what
they might have been, specifically.

Anyway, I'd rather code Lisp in Vim any day of the week.
 
M

M. Edward (Ed) Borasky

Chad said:
Isn't that what Smalltalk does? It combines the language and the IDE in
one convenient package. I'm sure I've seen a couple other languages do
the same sort of thing, but at the moment I'm drawing a blank on what
they might have been, specifically.
I don't know about Smalltalk in general, but that certainly describes
Squeak. So maybe it's been done. I gave up trying to learn Squeak --
perhaps I should try again. :)
Anyway, I'd rather code Lisp in Vim any day of the week.
Compared to what? Emacs? Vim has come a long way, and I must confess I
never learned Emacs, but if I had to do serious Lisp programming, I'd
for sure bite the bullet and immerse myself in Emacs. Actually, the
reason I learned "vi" instead of "emacs" to begin with is that the
system folks told us not to use "emacs" because it was a memory hog. :)
 
D

Don Levan

Thank you all for taking the time to answer my questions. Tim, thank
you especially for the suggestions on books and the idea of using a
deck of cards. I can certainly see how that would make things easier.

Don

Don Levan said:
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
 
H

Huw Collingbourne

Thanks for the extra information about 'semantic highlighting'. I can't
quite picture how we would be able to indicate scope information clearly
using this technique, particularly as we already indicate syntax information
with colouring.

However, it would be possible to display some kind of 'scope diagram'. The
fact of the matter is that our IntelliSense system already does all the code
analysis needed to provide scope information. It 'knows about' scope due to
public, private and protected; it knows about singletons, modules and
mixins, class, global, local and instance variables (and so on...) so all we
need to do is to find a meaningful way of displaying this information to the
end user. As I say, I'm not sure that in-editor colouring is the best way to
do this. Maybe a tree-view of some sort?

In fact, our IntelliSense already displays a good deal of this information
(different glyphs indicate different types of variables, whether or not a
method is public or private - and, of course, it only shows what is in scope
at any given point) but currently this is only displayed either in the form
of 'as you type' completion lists and parametr info or in combo boxes (the
code navigator bars over the editor). In that form, it doesn't fulfil your
requirements and I'm sure we can come up with something that does. I'm
adding this to our development Task List now ;-)

best wishes
Huw Collingbourne

http://www.sapphiresteel.com
Ruby Programming In Visual Studio 2005
 
R

rett

Don,

Mr. Abbott is far too literal minded to answer your message in a useful
manner. The algorithm that you were looking at would probably work in
more than a few programming languages, but it is best described as
what is known as meta-language. If you have ever had any form of
logic, it's form is the basic syllogism. In the final analysis, it is
basic,
logical English and does pretty much what it says it does. I will admit
that the syntax for arrays of one or more dimensions is not straight
English, and the downto is just crude computer slang, and there is not
what anyone would call proper punctuation, but other than those minor
bits of fluffery, it pretty much does what it says it does. The logic is
compressed, but if you understand the idea of assignment of values
rather than simple equality when the "=" sign is used in the "for" or other
functional statements, and that the same sign and all the other
comparatives
operate as logical comparatives in logical statements such as an "if", you
pretty much have it. That's not to say that it is absolutely simple, but
once you have the basics of how logic and function are separated and
combined in the peculiar form of computer geek illiteracy that is a
progamming language or a meta-language about programs, then you
can pick up speed over time. Of course, you'll never be able to read
this stuff at flank speed, because of the density of the expressions, and
the lack of foresight by the geeks that arbitrarily created the stuff.
In most
cases, their attempts to simplify their programming process(read use
the most shortcuts) have done the opposite of their intention for anyone
other than themselves. When you have all that in mind, you will be
prepared to suffer with the rest of us, each time we enter into a new
programming language that uses commas, periods, braces, brackets,
parentheses, colons, semi-colons, and etc. in subtly different and/or
grossly conflicting manners. Now, when you get ready to try to
understand regular expressions, take all of those problems and
multiply them by ten, then sprinkle the whole thing with holy water
and light a candle, or better yet, try a large firecracker or other
destructive device. It won't help you in learning it, but it will make you
feel a lot better until you can find something else to distract you.

Despite all this drollery, the suggestion on the Knuth books is spot on.
They are the best that the programming world offers. Just don't think
that they constitute " Programming for Dummies". Nothing that Knuth
says is either trivial or particularly friendly to the newby. On the
other hand, if you ever understand everything that Knuth has written,
you may skip the funeral and go straight to heaven or Nirvana or
wherever good programmers go when they are released from the
Stygian bowels of their computers.

Everett L.(Rett) Williams
Erwin said:
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.

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
 
M

M. Edward (Ed) Borasky

Tim said:
There have been some lisp dialects that combined the IDE with the language
similar to what smalltalk does.
Dr. Scheme comes to mind ... an IDE *and* a language tutorial. And for
Forth, there's the non-free and Windows-ia32-only SwiftForth package
from Forth, Inc. It's not as tutorial as Dr. Scheme, but it does come
with an excellent tutorial in PDF.
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Members online

Forum statistics

Threads
473,744
Messages
2,569,482
Members
44,901
Latest member
Noble71S45

Latest Threads

Top