Slashdot Mirror
SmartEiffel 1.0 Released
Per Wigren writes "Today SmartEiffel, the GNU Eiffel-compiler finally reached 1.0! Eiffel is a very underrated language in the free software community for some strange reason.. Hopefully this will help to gain some interest in this extremely powerful, fast, easy-to-read, easy-to-learn, almost self-debugging language!"
Then this link is for you:
http://archive.eiffel.com/eiffel/nutshell.html
I'd not call it is "forced" Object Orientation, but rather it is OO plus pre- and post-conditions in a methodology known as Design By Contract.
Funny you should mention that. Eiffel's the only language I've seen that actually gets boxing right. Any class can be "expanded" when declared or even used, and then it's transparently handled by value instead of by reference.
Eiffel is an object-oriented programming language designed to be replete with O-O-ness (no, really). For example, their are no primitives in Eiffel, everything is an object. Eiffel also has a singly-rooted hierarchy and garbage collection (like Java) and parameterized classes like C++.
Unlike Java, Eiffel syntax was designed to also act as a specification language of sorts, including syntactic support for contract specification.
Bertrand Meyer's book Object-Oriented Software Construction explains problems in modern software development, examines how object-orientation probably could solve them, then designs such a language. This language turns out to be Eiffel (sorry for the spoiler if you intend to read this > 1000 page book).
One of the points Meyer demonstrates is how a syntax to describe groups (classes) of solutions gets fleshed out into actual software that may execute. Eiffel, being that syntax, among other things, was intended to make you think in terms of types of objects sending messages to each other to get work done.
That said, I use Java. Why? Apache's Jakarta project.
Regards,
M. Murphree
Eiffel is a language with an minimal instruction set (sometimes refered to as RISC language), which is used mostly in environments that emphasize reliability and dependability. It's small instruction set (e.g. there is only one type of loop) make it easy to learn and understand but is taking away some of the fun of coding. Most of the work you put into an eiffel project is to find the right approache, because you don't have too many ways to implement stuff. Here in Europe it's used in mostly academic environments that like the grace of its simplistic approace and its 100% object oriented design.
Tradeoffs of this language are its high compilation time, as Eiffel source gets translated to C and then into a native form, the scarcity of available system libraries and the lack of dynamic features as shared objects and stuff.
If your going to invest some time in this language, a look at those open source projects might be worthwhile:
eposix - POSIX bindings for eiffel
gobo - a collection of tools and libraries to unify the development of applications on diffrent Eiffel compilers
mico/e - a CORBA ORB in Eiffel (DISCLAIMER: I am involved in the development of this project)
To learn more about Eiffel, read this and this and this and if you still have time, this.
Also, check #eiffel on freenode (irc)
Eiffel is the best,
DM
At its heart, Design-by-Contract is an API description mechanism (think assertions). For any given method on a class, you specify what must be true in order to call it (preconditions) and what it guarantees will be true once it has finished execution or has errored out (postconditions, exceptions).
In Eiffel, however, this kind of specification is given some heft in terms of compiler support. Design-by-Contract is especially useful when defining an interface between code bases (IOW: public APIs). DbC gives client programmers of a class insight into how to call the class, and gives the language a way to enforce and check for that.
Eiffel remains inherently an object-oriented language, but in recent times it has borrowed some functionality typical of functional languages, through the new agent mechanism (think of iterators, map and for-all).
writing valid code.
it has pre and post conditions BUILT IN to the system. so it isn't like a comment or an if statement in the function, you say, this function only accepts x if it is between y or z... or any number of boolean statements... if it fails, the system fails. it makes your code very solid.
MARIJUANA, SHROOMS, X: ONLINE?! - E
Eifel also has plug in and compiler support for Microsoft's .NET initiative. It's pretty cool, actually, because although .NET does not have support for genericity in V1.0 (though it's planned for v2.0), Eifel.NET has overcome this limitation and allows for multiple inheritance and other cool stuff. Take a look here.
There's also an MSDN article.
-jerdenn
Yes there is an example in the distribution. Just go to the example directory and compile.
Well, since all Eiffel code involves classes, you need a class creation procedure. Comments are literally indicated with a --
:= "Hello World!%N"
Here goess
class ROOT_CLASS (specifying the name of the class)
inherit ANY -- (Not required, using an example of it's multiple inheritence feature which --Java does not have)
creation make -- (the creation procedure for this routine, equivalent to C++ *p = new (class))
feature -- (functions and attributes class has)
make is -- function name
local statement : STRING -- local attributes
do
create statement.make(0)
statement
io.put_string(statement)
end
end
Well, as a current student at the University of Notre Dame, Eiffel was used in our Data Structures course. We basically had two options, Eiffel or C++. Not a lot of people picked up on Eiffel simply because they were stubborn. But as a whole, the Eiffel coders had consistently better projects and overall success. It's purely O-O, so that takes some getting used to. The Design By Contract is an excellent tool for writing perfect code the first time, thus getting a larger systems to market faster. And the libraries that are available are excellent. The STL is simply not good enough relative to EiffelBase. Bertrand Meyer, founder of Eiffel Software, gave three distinguished lectures here this week, and another to our class, and he's very convincing when it comes to his methodologies. It's a great language for teaching O-O and Contracts. Additionally, the same code runs on multiple platforms, and EiffelStudio is available for free for Windows and Linux. EiffelVision also makes it possible to create GUI's that will compile on Windows and Unix too.
actually, I was a TA in a class that used Eiffel.
Being an experienced Java programmer also,
I would say that:
What SmartEiffel lacks is good support for dynamic loading and reflection. Those are crucial features for many real-world applications these days, and given SmartEiffel's compilation strategy, they'll be very difficult to add.
SmartEiffel's performance was disappointing last time I benchmarked it--Sun Java beat it handily on equivalent problems. In principle, given its compilation strategy and static semantics, SmartEiffel should be able to yield very high performance code.
What's it good for?
It lets you ensure that the program you write does what you intend. (This is called Design by Contract. It works better than any alternative I've encountered.)
It manages multiple inheritance and limited generics in a way that C++ can't even try to approach. (Ada can do it, but it's a lot more work.)
And despite what has been said earlier, it isn't a memory hog during compilation. Not compared with the current competition. (Unless you are comparing it with C, of course.)
It's got a built-in garbage collector. Many languages do now, but it was quite unusual at the time, and it's still one of only a few compilable languages (excepting gcj == java) that have a gc.
It's got a good documentation system. Better than javadoc. (But the presentation isn't as nice unless you purchase the ISE development platform...which I don't recommend.)
I think we've pushed this "anyone can grow up to be president" thing too far.
In addition to all the great OO design by contract features mentioned by everybody I would add this:
An interface specification for a class can be trivially (and with smarteiffel or ISE tools automaticly) derived from the source. You won't have to go and learn JavaDoc or doxygen or anything. Take a look at http://smarteiffel.loria.fr/libraries/
for an example of automaticly generated eiffel class interface docs.
To me this is worth a lot. I find that when I write eiffel, I go more slowly than in C or perl (full OO and genericity make you want to think through your design more), but as others have said, long, complicated codes actually tend to work right or require only trivial fixes the first time. Not only that, but when they do, I have lovely documentation that describes them!
The only major problem is the lack of available libraries, and this situation is improving. There is a POSIX wrapper now, which was a major missing piece of the puzzle in my opinion.
Also, wrapping C libraries can be a useful exercise. OpenGL for example has bazillions of weird conditions that must be met for things to work right, my own little toy OpenGL wrapper formalizes some of these with preconditions and has already caught me a few times. (There is a more serious eiffel OpenGL wrapper out there but it seems to still be fermenting).
The wxEiffel GUI library provides a comprehensive interface to the wxWindows GUI. Database interfaces to Firebird, sqlite, berkeley db, mysql, postgres.
There are even libraries for Regular Expressions and for those who like the perl way of doing things - see Perlish.
The 0.5 release announcement in comp.os.linux.announce gives more details. The ELJ project is undertaking the necessary work to move from SmallEiffel to SmartEiffel.
There are many other open source Eiffel projects:
Eiffel has come a long way over the years. Misconceptions still abound. You can now develop multiplatform applications using open source Eiffel tools and libraries. There are small hurdles to jump as there are with anything. Give it a try and become involved if there is something about Eiffel which you find appealing.
Eiffel has been around for about 17 years, so a lot of people who used it a long time ago and haven't used it since moan about old problems with the language THAT SIMPLY DON'T APPLY MORE. Here is an up to date list of cool things about Eiffel:
.NET language. Eiffel Software have made a Visual Studio plug-in, and EiffelStudio (previously EiffelBench, or EBench) can also be used to make .NET or non-.NET applications.
.NET implementation of Eiffel adds some programming mechanisms that are NOT available in Java, C#, C++. Namely these are multiple inheritance of classes, genericity (true generics), design by contract (pre- and post- conditions/assertation to improve software reliabilty and greatly ease the debugging process).
.NET plug-in) from there web site.
- Compilation is not so slow anymore.
- It a full
- EiffelStudio is the IDE for creating Eiffel applications was COMPLETELY REWRITTEN a couple of years ago, so previous uses of EiffelBench won't recognise it anymore. The new studio is better in every respect and has the best class browsing facilities you will find in any IDE ANYWHERE (I'm not kidding).
- EiffelStudio was written using Eiffel Software's Vision2 library - a 100% platform independent library meaning it is identical on Windows and *nix platforms. You can use Vision2 to make your own cross-platform interfaces with real ease.
- The
- Eiffel Software provide a FREE version of EiffelStudio and Envision! (the
There's loads more to this language, but aint got time to talk about it, so just check it out yourself.
Rake Free + Mac Poker: CardCrusade
This may be of interest to you.. html
http://www.info.uni-karlsruhe.de/~sather/dl
I can't say how much development is being done on this as my German is very basic but it doesn't seem to be a dead project.
Pain is merely failure leaving the body
The free version of Eiffel Studio for linux is available here.
This is an example of an extremely well written Gtk application and provides gtk bindings as well as multi-platform libraries that allow applications to run on, if forced to, Windows with absolutely no change of code yet retaining full platform look and feel. Very cool stuff indeed
-- You see what happens when you have fun with a stranger in the Alps?
Forth beats all of you:
.
'Hello World'
For a nice IDE for Eiffel you should get the Eiffel extension for the SNiFF+ environment
http://www.willamowius.de/eiffel.html
There are free versions of SNiFF+ for projects up to 200 (?) classes which should be ok for starters.
1. Because RMS forbids it.
2. GCC is a GPL'd program.
A front end for GCC would make the front end also a GPL'd program. This has been hashed over a million and one times in the GCC mailing list.
The IDE is free only for non-commercial use...
Sure, it might be the French *Foreign* Legion. But there sure were some French guys there driving the train.
Yes, the vast majority of WWII was not too pretty...however, Dien Bien Phu -- while a failure, was not a surrender. And that difference is incredibly important. Dien Bien Phu would be impressive by itself. But Camerone gives the French, and the French military, something that no one will ever be able to take away. And if you don't understand what I just said, then I will never be able to explain it to you.
The day after Camerone Day, like the day after Veteran's Day, is a day that I will always manage to get off...because I'll be so hungover that I wouldn't be able to work.
-- An Anglo-American that spent many, many years in the U.S. Army (with a large amount of time being shot at in Panama, Iraq, Bosnia and Somalia).
and it's still one of only a few compilable languages (excepting gcj == java) that have a gc.
There is nothing special about a "compilable language" (whatever that means) using GC. Lisp has been doing it for decades (and yes, most Lisp systems are native code compilers, such as CMUCL, Allegro, CormanLisp, SBCL, etc). Oberon-2 compilers use GC, including the open source OOC and Oberon System3 from ETH. Ada was designed such that GC could be implemented, but it rarely is. Many FP languages use GC, such as Haskell. Haskell compilers, such as GHC, NHC, and HBC all use GC.
If you haven't gotten the point yet, there is nothing special about implementing languages using garbage collection, and furthermore, there was nothing innovative when Meyer decided to use it for Eiffel.