Top Ten Reasons to Use Smalltalk

Top Ten Reasons to Use Smalltalk

• Smalltalk - it just works
  

  Ask the dedicated (fanatical, even) developers who use Smalltalk. They'll explain that Smalltalk is simply more productive, and enables a 3X boost in time to market over the competition. Can you afford to deliver your software later, just because everyone else is using Java? What did your mother tell you about what everybody else does when you were a kid? Switch now to something more productive, more usable, and simpler. Switch to Smalltalk.

• It doesn't create brittle software
  

  Take a look at any middling size or larger system built in a mainstream language. How easy is it to change things? How easy is it to replace a layer of software that other components depend on? If you are honest with yourself, you'll say that it's hard. Why is it hard? Manifest (static) typing locks in design decisions about components early, and makes changes harder as time goes by. Smalltalkers have known this for years, and have demonstrated that quality (lower numbers of defects, according to SPR research numbers) can be delivered using dynamic systems. Why make your application difficult to change when you don't have to? You know that your application will be in production longer than you would care to think, and that requirements for it will change over time. Switch to a system that enables change.

• Simply the best for XP
  

  XP is the hottest topic in design and delivery of software right now. There are dozens of trade shows, and many well known people espousing it - in person and in books. Where did XP come from? Ask the XP elite - or read any of the books, and you'll find out. It came out of Smalltalk projects and Smalltalk practices. Smalltakers were doing XP before anyone called it that, and still have the best tools for it. Test-First? Smalltalk is incremental. Frequent release? Smalltalk enables immediacy. All the XP tenets came out of Smalltalk, and the XP elite will admit - sometimes reluctantly - that it is still most easily practiced in Smalltalk. So why use a system that makes XP harder, and erects roadblocks to its adoption? Switch to the system that gave birth to XP.

• Refactoring? Where did that get invented?
  

  Refactoring of older code is something that all developers do, whether working in XP or not. However, some systems make refactoring harder than others - due to inherent brittleness. Refactoring browsers are starting to appear for Java, and C#, and other languages. Where did the concept and initial implementation come from? That's rfight, Smalltalk. And Smalltalk still ships with the most powerful Refactoring tools. Every Smalltalk system either ships with a refactoring browser, or has a loadable one available. Why would you want to work with pale imitations? Smalltalk is a fully reflective environment, enabling refactorings that other systems can only dream of. Download a Smalltalk environment today and learn for yourself!

• Your own software playground, with connectivity to everything
  

  Smalltalk was designed to be an exploratory environment. The last 30 years of software development have taught us that incremental, exploratory design - where you should be unafraid to throw away code that isn't quite up to snuff - is what works best. And yet, most developers continue to work with systems that discourage such practices. Smalltalk enables exploratory programming much better than the mainstream systems, and the productivity boost is such that throwing away non-optimal solutions is easier. Why work in systems that make exploration hard? Switch to Smalltalk, where exploration and play are encouraged

• Portability - everywhere you want to be
  

  Smalltalk is available on every platform you care about, and in every possible flavor. Need to be binary portable across a wide range of platforms? There's a Smalltalk for that. Need to be portable across a range of platforms, but still deliver a platform native solution? Smalltalk can do that as well. Need to worry only about one platform, and be very tightly tied into the services there? Smalltalk does that as well. Need a fully Open Source solution? Smalltalk delivers there as well! Can Java, or C# do those things? No, they really can't. Your needs vary - why use something that limits your choices? Switch to Smalltalk now, and deliver the right solution!

• Full network connectivity and more
  

  You need support for all the new and existing network protocols, and the ability to customize when needed. Smalltalk delivers that! Web Services? CORBA? DCOM? FTP, Mail, etc.? Smalltalk does it all. And unlike the competition, Smalltalk delivers with full, modifiable sources. Did the vendor ship with some flaw that will be fixed in some future version? In Smalltalk, you can fix the base libraries right now. Can you do that in the mainstream solutions? No, you can't. The libraries are what they are. Can you afford to wait on someone else's schedule for a critical fix? Switch to Smalltalk, where you not only get the libraries you need, but the sources and flexibility you require!

• Continue to use all your standard tools
  

  You probably have plenty of code lying around in C, scripting languages, Java, etc. You don't want to throw that away, and rewrite from scratch - and Smalltalk doesn't ask you to (unlike the Java world, where the evengelists would have you waste your time and money doing exactly that). Use Foreign code interfaces, web services, CORBA, and COM to connect to everything you have. Don't rewrite - reuse. Smalltalk invented OO, and reuse means more than just Smalltalk. Why waste valuable resources on rewrites? Switch to Smalltalk, where reuse is king!

• Interoperability with everything
  

  With hooks to every interoperability standard there is, and versions for every platform you want to run on, Smalltalk delivers full interoperability. Don't tie yourself to a single platform - use the best tools that work well across a wide range of platforms and problems. Switch to Smalltalk, and start seeing how productive you can be!

• It's Elegance defined
  

  Developers like elegant solutions. The mainstream systems simply aren't built for that. Using the tired, standard C language paradigm delivers solutions in a workaday way, slowly, and without elegance. The solutions are hard to reuse, and hard to appreciate. Take a look at Smalltalk - it's a pure OO system. Everything is an object, and everything is open for you. Need to change a base class to support a simpler, more elegant solution? Go ahead, and version that change off in an easy to maintain way. Can you do that in Java, or C#? No, you'll take the vendor's libraries and like them! Elegance and maintainability are sacrificed on the altar of standards (and false ones at that). Do you need to stop working around limitations you know you could fix? Do you want to deliver not just solutions, but elegance? Switch to Smalltalk, and see where you can go!