CopyMem Quick & Small released!

[Thorham]

Lol at Vim (68k AOS).

[Thorham]

Don't dare to say anything more bad on (micro)emacs or I'll turn this thread in a classic emacs vs. vi war thread. And if you think the infighting on amiga.org is bad; I assure you you ain't seen nothing yet...

On 68k AOS that's irrelevant, because the mighty FrexxEd destroys all

[Thorham]

Why use Ed at all?

[Thorham]

Because it is free (with AmigaOS), available and works.

Didn't just about every version of the OS come with MEmacs?

I went to CED 3.5 and then CED 4.20 where I am now.

Yeah, CED. Used to be my favorite, until I wanted more features and found FrexxEd.

I wish an "editor" wasn't so expensive to upgrade and the process easy (my CD has no serial number).

You could use a free editor. What does Ced do that free editors don't?

The Amiga has many good editors now like CED, GoldEd, FrexxEd and BED.

Never did understand why people like GoldEd. I tried that thing once and ran away screaming.

In my opinion CygnusED is the best on Amiga

It depends on your needs and what you want. CygnusEd is a little on the simple side for me now. Just the other day I was thinking about NotePad++'s nice multi line editing feature, so I added it to FrexxEd with a simple script. Hard to beat that kind of power.

[Thorham]

Yes, but that didn't make it any better.

It still seems better than Ed at least. Then again, it's hard to be worse than Ed

Because you can configure it to your liking. In fact, once you know how to handle it, you could configure it for an entire IDE. In my personal configuration, I compiled from it, installed compiler settings, makefiles, jumped to errors in the source file and much more. It was a very powerful editor, and for Amiga business, I still use it.

What I hate about GoldEd is the fact that it has a weird editing model that I can't stand. I like things to work like Ced and Notepad++ (standard editing model). FrexxEd does that, and offers full programmability. You can play Tetris in that editor. I also hate how CubicIde uses Lisp as it's scripting language. Terrible! FrexxEd uses FPL which is just a C interpreter.

The big drawback of FrexxEd is that it's default setup isn't all that great.

[Thorham]

Well, it worked for Emacs

Just that is reason enough for me to never use Emacs.

Should you wake me up in the dead of the night, stressing that the fate of the world depended upon me instantly adding scripting language support to an application, I'd probably start yawning, make coffee and write a Lisp-like language interpreter.

Or you could get Lua, and add that. Seems a lot easier than writing a script language from scratch. Not to mention that Lua is a lot nicer than Lisp.

With the exception of "Forth", there's probably no other type of programming language which is both robust and powerful, and as easy to implement. Whether this necessarily translates into a language which empowers the user or just succeeds in making his life harder is up for debate.

Lisp is probably quite usable once you're used to it. The question is whether you want to get used to it or not. I certainly don't.

Sometimes it's enough just to make a system scriptable which wasn't scriptable before.

Why not just add a nice language? Best choices for a script language seem to be Lua or a C interpreter.

Lua is easy, and easy to add if you're working in C. It's also pretty fast, works well on old systems like lower end 68k Amigas (68020/30), and very portable (SASC compiles it properly).

Adding a C interpreter is good, because many programmers know C. That's why FrexxEd's script system is so nice. If you know C, then you know FrexxEd's script language.

[Thorham]

I used ed for the startup-sequence.

We've all done that at some point :lol: Ced is nice for stuff like that. Solid and fast (but a little on the basic side).

I don't even remember which editor I used in the old days when I did a lot of in assembly. Really a lot. I looked at seka, and had to p*ke about its user interface (or lack thereof) and decided against this primitive beast (a good decision), then used the Databecker "Profimat", which had a somewhat useful IDE, though a pretty limited assembler (not a good decision). Luckely, decided against the GFA assembler (I also used GFA Basic quite a bit, fast but buggy) and bought DevPac (2.0 back then), never regretted it, it was a decent choice. I believe I used the DevPac editor for quite a while, still a good thing. Then with Lattice C, I believe it was LSE, which had a couple of bugs, but still worked quite ok. Then came GoldEd, SAS/C and DevPac 3.0, again good investments. I guess I was never a particular fan of CED, but I already had good editors for what I needed. GED I used for almost everything, C, Assembler, PasTeX. Except for the Startup-Sequence. That was still in the hands of "Ed" because GED was a bit too bulky.

Back in the day I used to do everything in AsmOne. Now I do everything in FrexxEd, with Barfly for assembly language and SASC for C.

Sometimes you don't get to choose, and there are overriding constraints which spell out in so many words why we can't always have nice things.

Yes, but not when you're developing your own software from scratch.

Being a programmer can suck.

Yes, but not when you're doing it on a hobby basis. Then you get to do whatever you want in whatever way you want. You simply need the discipline to actually finish the project, or get it into a state where it can be released and used properly (after that you can keep working on it to make it better, but at least you already have something decent).

I think that Lua's a decent enough design, which is both powerful, well-documented and something newcomers can learn and apply. It's also embeddable with a small memory footprint. I once came close to using it in one of my applications, but then time constraints made me - wait for it - knock off one of those Lisp-like language interpreters instead (the fate of the world didn't exactly depend upon it, and if it did I didn't notice, but sometimes you just want to finish a project and not keep on tinkering).

What kind of time constraints cause you to have to make concessions like that?

As for using a 'C'-like language for the purpose of scripting, I can see the attraction for programmers who are already familiar with the language. For everybody else it's a long and ardous journey to even become competent in using the language, so I wouldn't want to force it upon anybody.

True, but it's still great for programmers editors because so many programmers know C. For something that's not related to programming I'd pick something else, too.

[Thorham]

For the love of the Amiga, please DO NOT USE or write on forum this compilator at all...

Here an example of what I have found in the GRex Voodoo3 monitor :

It's AWFULL : DO NOT USE THIS COMPILATOR !!

I'll keep using SASC because it's fine. Perhaps you should do some proper tests first instead of looking at one piece of code. Also, what's the alternative?

Anyway, 68k compilers in general won't produce top notch code. If you really want good code, then use assembly language.

[Thorham]

However, not all applications really need that power, and they still get the job done which they were intended for. So plugging in the Lisp-like language interpreter solved the problem at hand, with a minimum of implementation and testing effort. Lua would have provided a much more powerful and well-rounded solution, but I would have had to spend another day or two to get it working properly, and just maybe I wouldn't have used the flexibility and options which Lua would have provided anyway.

It depends on the software, sure, but for some software you shouldn't make such concessions.

For some software, 'limitless power' is part of the design goal. FrexxEd is a good example of that, and it's script language is the main reason why it's so powerful.

[Thorham]

Not really.

No, really. I'm not talking about all software, I'm talking about some software. In these specific cases the goal of the author/authors was to create software with 'limitless power'.

FrexxEd is an example of such software. From the manual:

Code: [Select]

   What is FrexxEd?
    ================

 FrexxEd is an advanced, highly customizable, extensible, real-time, zero
limitation, fully programmable, function driven full screen display editor
(not a word processor) for editing text files (even though it's possible to
edit any kind of file).

 We say that FrexxEd is a "display" editor because normally the text being
edited is visible on the screen and is updated automatically as you type your
commands.

 We call FrexxEd advanced because it provides facilities that go beyond simple
insertion and deletion.

 "Customizable" means that you can change the definitions of FrexxEd commands
in many ways. For example, if you don't want FrexxEd to query if you kill a
modified buffer, you can simply tell it so. Another sort of customization is
rearrangement of the command set. For example, if you prefer the four basic
cursor motion commands (up, down, left and right) on keys in a diamond pattern
on the keyboard, you can have it.

 "Extensible" and "fully programmable" means that you can go beyond simple
customization and write entirely new commands (programs in the FPL language).
FrexxEd is an "on-line extensible" system, which means that it is divided into
many functions that call each other, any of which can be redefined in the
middle of an editing session. Any part of FrexxEd can be replaced without
making a separate copy of all of FrexxEd. Many of the editing commands of
FrexxEd are written in FPL already; the exceptions could have been written in
FPL but are written in C for improved efficiency. Although only a programmer
can write an extension, anybody can use it when it's done.

 We call it a "real-time" editor because the display is updated very
frequently, usually after each character or pair of characters you type. This
minimizes the amount of information you must keep in mind as you edit. (The
term 'real-time' is, according to some, not used in its right sense here, but
I think you all get my point!)

 "Zero limitation" means that there are hardly no limits in amount or size in
FrexxEd. Your amount of primary memory is the biggest limitation.

 Every keystroke in FrexxEd invokes a function. Most keystrokes invoke the
`Output()' command which inserts the string/character stored in your AmigaDOS
keymap for that key, but there is no real limit to what can be done with
merely a simple keystroke. If FrexxEd cannot already do it, it can be
programmed by the user to do it.

 FrexxEd is not an every man text editor. It's for people with a large
customizable need, brains and more than a 512KB or 1MB floppy system.

 FrexxEd is ShareWare, coded with the intension to give the world a superb
editor to everyone for a low price.