Slashdot Mirror
EiffelStudio Goes Open
WeiszNet writes "Bertrand Meyer, the creator of Eiffel the language and CTO of Eiffel Software in Santa Barbara, CA has announced in his Software Architecture course at ETH Zurich that the company's flagship product - EiffelStudio was released under the GPL today. Here is the press release: and the project's page.
Eiffel is an object oriented programming language supporting contracts. Last year the international standard (ECMA) for Eiffel was released and now the initiative to go open has been taken."
This was the #1 reason for not using Eifell.
Eiffel is an object oriented programming language supporting contracts.
I was beginning to get concerned about the incredible lack of object oriented programming languages currently available.
Fortunately, there's now another one to choose from that is now free.
I'm a big tall mofo.
Wikipedia knows.
The big thing is design by contract. Calling procedures specify what they will guarantee functions and what they expect, functions guarantee what they won't change and list what they expect. This makes code reuse actually practical, since global effects are spelled out.
For example a sqrt function will require x >= 0, that is the calling function must have checked. Since this is specifically listed in the contract your calling function is expected to be able to indicated how it knows that x >= 0 before computing sqrt(x).
The second big thing is that the language is pretty high level and you just give hints to the compiler about how to implement things (sort of like Oracle SQL) unlike Java or C++ where implementation details are definitely part of the program.
That's pretty much it.
I haven't heard of this language, and don't want to do too much research (go go procrastination!). Can anyone tell me some of the basic info about this, and what makes it different? Why would I want to use this language over something already available, for example.
Eiffel has been around for a long time, and is a mature language. What does it offer? A very clean and well designed Object Oriented language with a very clear and readable syntax and great support for Design by Contract. The principle behind Design by Contract is simple enough: objects, and methods provide contracts - providing you meet their stated requirements, the guarantee things in return. Statically typed languages offer some level of this already: you have to provide paramters of the right datatype, and it guarantees the datatype of the return type. Design by Contract essentially just extends this principle to allow for much more expressive contracts than just type signatures, and things like object invariants (properties of an object that are guaranteed not to change). The result is a much clearer statement of intention as to how code should work, and a powerful test harness that massively speeds up the test/debug cycle. In theory you can achieve this by liberally sprinkling assertions through your code. The advantage of having a language with explicit support for Design by Contract is that things like inheritance of contracts and invariants are all handled automatically and elegantly etc.
As well as this release of EiffelStudio as open source, there's SmartEiffel which is an open source Eiffel compiler (which supports a number of extra features beyond what is given in the recent ECMA spec).
Jedidiah.
Craft Beer Programming T-shirts
The link for the project page goes to a wiki page with not too much information. Not to sound too much like a slashvertisement, I'm sure they would want you to also link to this page, containing more information:
http://www.eiffel.com/products/studio/
Also there should be a PDF warning on the ECMA standards link, just a thought.
What are the odds that some idiot will name his mutex ether-rot-mutex!
I'm having first year comp sci flashback! I remember at the time being taught Eiffel as my first OO langage used to teach OO techniques and design - I hated it back then it felt clunky, overly protective and claustraphobic. Now after almost 10 years as a programmer every so often I crack open the old textbooks and think "wow.. that is rather elegent and expressive". Eiffel is engineered/designed - it is deliberately not suited if all you want to do is hack about. It's funny, only yesterday I was using Eiffel as an example to my IT team as a language that forced strong contractual based interfaces.
I just can't be bothered.
In other words, Algorithms + Data Structures = Programs. I'll be damned ... that Wirth guy was right after all.
The higher the technology, the sharper that two-edged sword.
As a language, Eiffel doesn't make it more convenient to express a problem to receive a good solution, it just makes the programmer follow the public speaker's maxim:
Programming by contract is essentially just writing twice as many unit tests, wrapped all around the code that is supposed to be doing the work. It's even easier to write bad tests when it's right next to the code being tested, so why bother?
Bertie, give it up already!
[
I've heard of Eiffel a number of times. The contract by design feature intrigues me; I've always wanted to try it. Well, I guess now I have more incentive. I don't think there's anything like it in the more common languages - C, Python, Java, etc. When I'm coding, I usually try to force myself to make decisions about which objects/functions are responsible for what. But it never seems to work out that way. Things decay over time.
I've wondered just how much a language can compensate for programmer laziness, carelessness, or just lack of ability. This question recently came up in a discussion. I am somewhat confident that software or languages can be designed to force good behaviour and eliminate (certain types of) mistakes. After all, there are no memory leaks in scripting languages, right? And you can't write to memory that's not yours. In lisp, it's harder to make off-by-one mistakes than in some other languages. Java forces you to handle error conditions with checked exceptions.
Yeah, I'm going to have to try this eiffel thing.
For all of those hearing about Eiffel for the first time. Back in the mid 80's, when the OO paradigm was first starting to gain traction (but it wasn't obvious that C++ would become the first mainstream object-oriented language) there were debates about whether the big OO language of the future would be C++, Smalltalk, or Eiffel.
1) Designed for native compilation. Compare it vs. Common Lisp and C++, not the modern enterprise toys.
2) Design-by-contract. Think of it as taking type-safety squared. Just like static-typed languages are more verbose but compile-time safer than dynamic-type languages (don't argue static/dynamic, you know damn well what I mean), design-by-contract is moreso.
3) Extremely generic-oriented and had generics designed in, as opposed to the after-the-fact hacks that appeared in C++, Java, and C#. And it has multiple inheritence.
Plus, I'm also very disappointed by all the languages you listed being non-generic Algol family languages. That's like asking someone "what's your favourite beverage - Coke, Pepsi, or RC Cola?" The example languages you listed are all of the same line of descent (although Ruby pulls more from SmallTalk than the others). Plus, most of the languages you mentioned are just a mishmash of features. Eiffel is more like "Lisp" in the mentality of design, which is "keep the language simple but make it expressive enough that complex concepts can be expressed simply anyways".
Such languages tend to be much more intelligently structured, safe, and extendable, but also fall short in legibility.
Basically it is similar to Ada and C++, with a little functional programming thrown in. The problem is that most attempts to make C++ "safer" have focussed on ripping out language features like multiple inheritence and templates that made it "too complicated" but were important, useful features. Eiffel takes the alternate approach - instead of paring down the featureset, it pares down the language while actually expanding the featureset.
And if you've never coded with generics and still just typecast your container data: get out of my sight you disgusting hacker. OOP without generics is like a car that only turns left - sure you can go right, just do three lefts.
You aren't remembering correctly, he went after all open source and free software. His biggest criticism of Stallman and Linus was for not distancing the free software movement from the NRA when Raymond tried to link the two (he held Stallman more responsible since Linus being a Finn might not have known what the NRA was...). He attacked FreeBSD explicitly for poor quality.
r e.html
What is funny though he lists a whole bunch of reasons vendors turn something open source that pretty much amount to "it isn't worth keeping as commercial product for reason X" where he lists the possible X's. Anyway here is a reminder:
http://www.apostate.com/programming/bm-freesoftwa