For Software Developers, Suneido™ is a complete, integrated application platform that includes an object-oriented language, client-server database, and user interface and reporting frameworks to enable you to create, deploy, and maintain applications easier and quicker, with more features, and less code. Suneido™ is Open Source Software – provided FREE, with complete source code, to give programmers full control over their development projects.
The release of Suneido, under the GPL Open Source License, opens an exciting opportunity for developers of business and information systems software everywhere.
In this interview, Ken Sparrow talks with the chief architect of Suneido, Andrew McKinlay, CTO, Suneido Software Corp.
by Ken Sparrow © 2000 Suneido Software Corp.
Sparrow: What is Suneido?
McKinlay: Suneido is a platform for developing business applications and information systems that includes a language, a database, and user interface and reporting frameworks.
Sparrow: Why do we need another computer language?
McKinlay: Every language has its own strengths and weakness. For a given job there are always things that a language could make easier or could make harder to do. Suneido is designed specifically for business applications and information systems – most languages aren’t designed for that.
Sparrow: Aren’t all languages made for doing business applications and information systems?
McKinlay: No – there are some languages that are meant to be general purpose, like C++ or Java. You can use pretty much any language for any purpose. But just like mechanical tools, if you have a tool that is designed specifically for a job, then it makes it easier and faster to do that job. You might be able to use C++ or some other language to build your management system, but it is going to be quicker and easier and better to use something that is designed for it, like Suneido.
Sparrow: What other languages are like Suneido, in that they are designed for doing a specific type of application?
McKinlay: Perl, another Open Source language, was designed for text processing for web applications. That’s what it’s good at. It doesn’t really compete with C++. The kinds of things you do with Perl, you wouldn’t do with C++ or Java and vice versa.
Sparrow: What will Suneido mean to software developers?
McKinlay: In general, it’s a new weapon in their arsenal, a new tool that they have available. If they’ve got to do the kind of job that Suneido is best at, then they can use Suneido and do it a lot more quickly, and a lot more easily and produce a better product than they could using some other language.
Sparrow: What major benefits will Suneido provide that are not available with other languages or databases?
McKinlay: One of the biggest advantages is that it is a totally integrated system. With a lot of other languages and development tools you’d have to piece together all the things that Suneido gives you. You would have to get a database from one place and a language from another place and you’d have to get the user interface framework separately, and the reporting tools separately.
You can do that, but obviously it’s a lot more hassle. It’s far more trouble interfacing them. They don’t all fit together perfectly and they all have their own ways of doing things. Because Suneido is completely integrated, everything fits together. This is a huge benefit. It’s an “all-in-one package”.
The other big advantage, for the kinds of applications that it’s designed for, is that it is faster and easier to develop software. Because of all of the things that it includes, the resulting applications will have far more features than they would if you were to design them with a general purpose language, such as C++. So you end up with a better application.
Another major benefit with Suneido is the ability to customize your applications to produce slightly different versions and still be able to maintain a common standard version as well. You are able to make changes to the standard and have those carried through to the tailored versions. That’s something that none of the other mainstream languages support. It’s a major benefit. Obviously this is a huge benefit if you are doing custom programming or vertical applications, but even if you’re not, almost everyone has to maintain slightly different versions of their product, whether it’s a light version vs. a professional version or it’s development on different platforms, or some other scenario. Being able to make this type of modification has big benefits even if you’re not explicitly doing that kind of tailoring for your customers.
Sparrow: What kind of problems that software developers face will be solved with Suneido?
McKinlay: Handling multiple versions of applications is a big problem. If your language doesn’t have support for this, it can be a major headache. Of course, there are ways around it. You can use separate tools. And there are different approaches to handling the problem. But this is far more awkward then having the support for it built in, and available all the time. Getting the integration we are talking about is often a big problem to people. You might try to use a version of Java, and someone’s database, and they don’t fit together. This kind of integration is a major problem.
Sparrow: What about productivity issues?
McKinlay: Obviously, throughout the industry, there is backlog of application work. There is a great deal of pressure to develop software faster, better and with fewer bugs. Those are problems that Suneido tries to address. For the kinds of applications that it’s aimed at, it’s going to solve those problems by helping developers produce better applications, faster.
Sparrow: When Axon’s [editor’s note: Axon Development Corporation is Suneido’s parent company] first application development system [C4] was released, one of the major highlights of the product was the dramatic increase in productivity, in terms of the amount of code that had to be written to develop products and so on. Has that changed?
McKinlay: No, I guess we sort of take that for granted now. We still have major advantages over a lot of languages, and with Suneido, it’s improved again over our previous versions. It depends on what language you’re talking about and the approach you are using. But there is still going to be far less code using Suneido relative to C++ or Java, for those kinds of projects.
Sparrow: How about relative to other integrated development environments like Delphi or other popular, visual language products like Visual Basic?
McKinlay: Programs like Visual Basic and Delphi make it really easy to draw out screens, but they fall down when you want to go farther than that. Once you get to where you want to make that screen behave in a certain way, then you are back to programming. And in Visual Basic’s case you are back to programming in Basic, which is a pretty old language, and not a very powerful one. In Delphi’s case you are back to Pascal, which may be a little bit better but it’s still not a terribly modern or powerful language. So yes, you get the fancy front-end, which might save you some time on that very first step of designing an application, but they’re not going to get you any farther once you get into the hard part, the behavior of the application.
Sparrow: What’s the competition for Suneido?
McKinlay: Well again, to do the kinds of applications that Suneido is aiming at, people use a lot of different tools. Visual Basic is pretty common, and Delphi. People use database products like Oracle, which have their own language and tools. And then there are general purpose languages like C++ or Java or Smalltalk.
Sparrow: What makes Suneido a better option for developers of information systems than Visual Basic, Delphi, C++, and so-on?
McKinlay: Probably the biggest thing is that it’s a complete, integrated solution. There are many other more detailed points that make it better, that we’ve already discussed. But again, most of the competitive products aren’t integrated. There is competition for portions of Suneido – for example there are lots of options for databases. If you are using C++ then you’ve got to pick somebody else’s database. The same with the user interface. One of the common ones is Microsoft MFC, but there are other packages you can use. The same is true of reporting tools. There is competition for individual components as well as for the basic language.
Sparrow: Is there any product that is all-inclusive and as extensive, not just feature-benefits-wise, but in terms of a general product that does all these things that Suneido does?
McKinlay: Not really. I don’t think there’s anything out there that has all of the components and advantages of Suneido in one package. Certainly for any given portion of it, there might be some competition and there may even be features that people would argue are better in one component or another. But as an overall complete system, there’s nothing really out there to compare with it.
Products like Visual Basic and Delphi would probably come the closest. They often come packaged with databases or access tools for databases and they have the user interface framework. But both of them are weak on the language side and also on reporting. Reporting is obviously a major requirement of information systems and neither of them really have much in the way of reporting tools.
Some of the databases like Oracle, with their tools would come close to providing the same kind of package [as Suneido]. Again, their languages tend to be really weak, because nobody ever sat down to design a language, they use just a conglomeration of commands and stuff that grew. They were never really planned out. Most of them aren’t object-oriented, don’t have very good programming tools, or debuggers or anything like that. And again, they are often lacking on the user interface and in some cases the reporting.
Sparrow: Can you talk a little bit about the object-oriented aspects and where some of these products are as strong or not as strong as Suneido?
McKinlay: Visual Basic isn’t really object-oriented. They’ve sort of tacked on a few object-based functions into the language, but it doesn’t support Inheritance and it doesn’t provide many of the key features of object-oriented programming.
The strongest object-oriented programming languages would be C++ and Java. But that’s almost a weakness as well as a strength for the kind of applications we are talking about, because they have so many features and aim to do so many different things, they tend to be very complicated. It’s very hard to write anything quickly in C++, which may not be a drawback when writing a large operating system or the kind of thing that’s it’s aimed at. But for doing business applications quickly, having so much complexity is a big drawback.
Suneido’s language sticks to the key important features of object-oriented programming, and simplifies a lot of the remaining stuff so it’s much quicker and easier to use. It’s much easier to use for rapid application development or prototyping
Sparrow: What would you say are some of the key important object-oriented features of Suneido that many other products may be weak in?
McKinlay: Inheritance is obviously a big one. Information hiding – the ability to have information private within objects, within classes is important. Virtual functions is another key feature.
Sparrow: Would you explain “Inheritance”?
McKinlay: Basically when you have an object it has two components, the information that it contains, (the data), and the behavior that it supports – its’ functions or methods. Often you need to share behavior between different objects. One object acts a lot like another but it’s got some special features or more features or slightly different ones. Inheritance lets you have one object inherit all of its behavior from another object and then add to or modify that behavior of the other object. It means you have to write a lot less code and it means you have a lot less duplication in your code. So if you’ve got to do changes, it’s far easier.
It also lets you treat different objects in a standard fashion. The standard example is if you’re drawing shapes on the screen that you can treat them all as if they have certain standard behavior. They have the ability to be moved, or they have the ability to be colored or resized. They inherit all of that behavior from a standard, shape object and then you just over-ride the specifics of their particular shape. But it means that you can manipulate that whole family of objects in a standard way. So, again, you’ve got less code to write and less code to modify if things change.
Sparrow: Another key feature you mentioned was “information hiding”. Can you explain that for us?
McKinlay: That’s the ability of an object to hide the information it contains so that it can only be accessed in ways that it allows. The main advantage of this is that it allows you to change the internal representation of that data without affecting any of the users of that object. Again, it makes it easier to make changes to your program. If you don’t have information hiding, if other objects are accessing each other’s internals, if you want to change the internals in one object, all of a sudden you’ve got a domino effect where you’ve got to change all kinds of code all over the place. And in fact it becomes a problem even to find all the places you’ve got to modify. Whereas if you have information hiding – encapsulation – it provides a firewall around each object, so that changes tend to be much more localized and don’t tend to ripple through the whole system.
Sparrow: It sounds like the reverse of Inheritance.
McKinlay: Yes, they go together. Inheritance lets you share the common stuff and Encapsulation lets you hide the differences.
Sparrow: What about Virtual Functions?
McKinlay: That ties back to what I was saying about being able to treat a whole family of objects that inherit from a common parent in a standard fashion. So you might be using a “Move” function on your shapes but it’s actually defined differently for each of the different shapes. That’s why it’s called a virtual function, because it doesn’t really exist in one form in one place. It’s implemented in a lot of different ways in a lot of different places, but you don’t have to know that to use it. You’re using it as if it was a standard function.
Sparrow: Are there any other features that Suneido provides that we should be aware of?
McKinlay: One advantage Suneido has is that it’s a dynamic language, like Smalltalk , rather than a static language like C++ or Java. That means that classes of objects are first class values, that you can pass them around and manipulate them, change them, create them on the fly, which is something you can’t do in a static language, like C++. So it gives more flexibility during development in terms of being able to make changes rapidly and try things out and prototype things. It also gives more flexibility in the final result in the applications themselves, because it’s a lot easier to manipulate that stuff. It means that you can store some of it in a data base or compute it or look it up from configuration information, that kind of thing, which is much harder to do in a static language.
Sparrow: OK tell me – why would I use Suneido instead of any or all other options or solutions that are available to me, including doing nothing?
McKinlay: One reason would be the Open Source aspect. Suneido is licensed as an Open Source product, meaning that it is freely distributed, with complete source code. People are much more willing to invest in something that is open that isn’t tied to somebody going out of business or somebody not wanting to fix some bugs or not wanting to make the changes that you need.
But, I guess the real reason that people would want to use Suneido is all the advantages that we’ve talked about – to be able to develop applications faster, easier, better. To get a complete integrated solution and not have to look for a whole bunch of components and try to put them together and worry about updates to each of them and that kind of thing.
As a developers’ tool, it’s a lot like Smalltalk in that the integrated development environment is written in Suneido and you also have all the source code for that. Every developer works a little bit differently and with most products, like Visual Basic or Visual C++ or Delphi, the development environment is fixed, you can’t change it. You might be able to tweak a few settings or preferences, but you’re stuck with the tools that they provide and the things that it does. For something like software development that varies so much, that’s not a very good thing. With Suneido, you can make changes to the existing tools, and you can add tools. We will be providing add-on tools to the environment. So it means that you are going to be able to tailor that environment to how you work rather than have to tailor how you work to the environment.
Sparrow: Those are the positive sides. What are the weak points? What is the down-side with using Suneido? Where would you not use it or why would you not use it?
McKinlay: Well, some people will regard the integrated solution as a negative, as well as a positive. They are not necessarily stuck with using our database but obviously it’s a lot easier to use the database that’s built in then to use somebody else’s. If you happen to be in an environment that requires you use some other database, or if you have existing applications, say that were in another data base, then that maybe counters some of the advantages of our integrated environment.
Another drawback – Suneido’s focus on business systems and information systems also has a down-side – I mean if you want to do other kinds of applications, if you want to do scientific stuff or if you want to write an operating system or that kind of thing, then it’s not going to work as well. You can use a general-purpose language like C++, which attempts to do everything for everybody, which means that it’s never really the best at anything. Or you can use the right tool for the job. If your job is to develop business applications or information systems, then Suneido is going to be the best at that. It’s going to be better than any general-purpose language can be, because it is more focused on the needs of that kind of development.
Sparrow: Let’s talk about some of the specific features of Suneido, that we haven’t already covered with respect to the benefits they provide. You have stated that, “Suneido includes a simple, complete object-oriented language. Its features include instant compile, no link”. What does that mean to the target audience for Suneido?
McKinlay: With a traditional language like C++, first you’ve got to compile all the pieces of a program and then you’ve got to link them all together. Both of those steps can be quite lengthy, especially the link, because if you change just one tiny part of your program, you’ve still got to relink the whole thing together. That slows down your turn-around and slows down the development process and makes it harder to try things or to do prototyping or rapid development.
Sparrow: What are the benefits of “dynamic types – no declarations”?
McKinlay: That goes back to what we were talking about before – dynamic languages versus static languages. Again, the benefits are in faster development in terms of prototyping, trying things out, developing things rapidly. When you’ve got a statically typed language you have to declare everything. Declarations can get very complicated, and there is a lot of extra code to write. Suneido, because it’s dynamic, can do away with all those declarations. It means it’s a lot easier to learn, quicker to write, less code to write.
Sparrow: Can you explain “Exception handling”?
McKinlay: That’s a feature that people are starting to realize is fairly crucial to writing good applications. It’s an improvement that was added to C++ that C didn’t have. It’s something that Java has. Again, it’s an area where older languages like Visual Basic or Delphi’s Pascal tend to be weak. Obviously in an application the error handling is crucial, both in detecting the errors and in handling them when they come up. Exception handing, when it’s built into the language, provides a clean and simple way to do that. Again, the benefit is a lot less code to write. If you’ve got to write the error handling from scratch, yourself, it adds a lot of overhead. Sometimes 50% of the code in, say, a C program could be devoted to error handling. By having exception handling supported, you can cut that down to almost nothing.
Sparrow: And “Automatic garbage collection”?
McKinlay: That’s the memory management, and that’s traditionally one of the biggest sources of problems and bugs in C or C++ programs. They traditionally, haven’t done any memory management or garbage collection because it was regarded as too slow, and too much of a performance overhead.
Other languages like Smalltalk and Lisp and Java have adopted memory management and garbage collection. Smalltalk and Lisp, were among the earliest to have it. The reason they did is that they are also dynamic languages like Suneido. This kind of automatic memory management is much more important if you are doing programming on the fly – doing rapid development. It’s very difficult to be worrying about the memory management, and doing it yourself, when you’re putting the stuff together fast.
Java is one exception, in that it’s a statically typed language, but it does incorporate garbage collection/memory management. I guess the thinking there is changing, that computers are getting to be fast enough that the overhead is not really significant. People are realizing that having your program maybe 5% slower is far outweighed by having so many fewer bugs and problems and more rapid development.
Sparrow: Suneido provides full access to the Window API and third-party DLL’s. Why is this important?
McKinlay: The benefit there is that you’re not restricted to using any limited set of functions that Suneido itself provides. You can use, obviously, what it provides, but you can also go outside of that and use any of the stuff that it doesn’t directly support. Obviously if you are talking about DLL’s or API’s then no standard language is going to have support for all of the third party stuff out there. Being able to still use those and access those is important, again for flexibility.
Sparrow: We’re talking about Windows compatibility, but what about Suneido’s portability. Can Suneido and Suneido applications be run on other operating systems – particularly Linux?
McKinlay: Suneido was developed with portability in mind. Platform dependencies are minor and localized. The largest dependency is the current user interface framework which is Windows based. However, the general design of the framework is portable, and since the framework is implemented entirely in Suneido itself, the actual executable contains no platform dependencies. Since the server side requires little or no user interface, it would be relatively easy to port to Linux. Porting the user interface framework to one of the Linux user interfaces would require some work, but is certainly feasible. One possibility would be to port to something like wxWindows which provides portability between Windows and Linux and potentially other platforms in the future such as the Macintosh.
Another option would be to write separate platform libraries that provide a common interface to applications. In any case, our goal is that Suneido applications would be able to run unchanged on any Suneido platform. This is the “write once, run anywhere” dream of the Java world, which has unfortunately been largely unrealized due to differences between Java versions & platforms. However, Suneido’s development team has a proven track record in this regard. Applications written with our previous version of C4 have been run unchanged on platforms as different as SCO Unix on Intel, Windows 3/95/NT/98/2000, VMS, and the Macintosh. We see no reason we cannot repeat this with Suneido.
There is currently a shortage of application development tools on Linux. Several companies are moving to fill this void, such as Corel and Inprise (Borland). We think there is an opportunity for Suneido in this market. We recognize that the Linux market has some unique characteristics that favor a certain type of product and marketing approach. Releasing Suneido as Open Source will help us to get a good reception from the Linux community.
Sparrow: Let’s talk about the database. You mentioned that it’s client-server. Would you elaborate?
McKinlay: Client-server means that Suneido consists of two parts. There’s the client, that focuses on the user-interface and there’s the server that is focused on maintaining the database. The advantage of a client-server system is that the database processing is done close to the data itself.
In a file-sharing mode, data-processing is done on the client machine, so it has to access all of the data across the network. This tends to be slow. With client-server, all of the data handling, the searching, and the sorting and all that kind of stuff is done on the same machine that contains the data, so it’s much quicker and it also puts much less of a load on the network. It also can work over a much slower network, which is becoming more of an important factor with people running across the Internet on different speeds of connections and people wanting to access applications remotely. It becomes a key enabling technology there.
Sparrow: What about “Transaction processing – roll-back”?
McKinlay: The database overall is probably the biggest area of improvement over our previous versions of C4. The transaction processing is the way that you handle multiple users concurrently accessing the database, and how you prevent them from interfering with each other and how you let each of them operate as if they were the only person using the data.
A real simple example is if you’ve got a banking system and somebody wants to transfer money from one account to another. First the system has to take the money out of one account and then the second step has got to put it into the account it’s going to. Now if somebody looks at your accounts in between those two steps they are not going to see the money in either account. They are going to get wrong information. Or if the system crashed in between those two steps, that money would be lost.
Obviously you can’t allow those kinds of things to happen in a real world application in a business system. The transaction processing provides a system of protecting your data and providing a consistent view of it. Again, you can do those kinds of things manually by writing code. But it tends to be very tricky code to get right. It’s very hard to test because it depends on who is doing what, when, and things happening in exactly the wrong instant. Having it built into the system means less code to write, and it’s much more reliable, much less likely to have bugs in it.
Then there are things like roll-back to deal with. For example, if you are transferring money from one account to another and half way through the user hits the cancel button, you can roll back that transaction as if it never happened. That doesn’t mean that you’ve got to undo each step individually, you just have to tell the database to cancel or abort that whole transaction. It looks after worrying about all the steps that you may or may not have done yet.
Sparrow: Suneido includes an “Advanced Query Language.” That’s fairly general. Can you explain?
McKinlay: The query language is the way that you ask for information from the database. The most common Query language is SQL. It has become the industry standard, which is unfortunate if you talk to any sort of database user or database expert – they will all tell you SQL isn’t a particularly good solution. It was written a long time ago and has a lot of things that are hard to do. It’s hard to teach, it’s hard to understand. It has a lot of quirks and oddities. Different things don’t work the same way, don’t work in standard ways.
Suneido uses a different Query language, developed by data base expert C.J. Date. It’s much more advanced than SQL is. It’s much more regular, it’s much simpler. At the same time that it’s much simpler, it’s also more powerful. It doesn’t have all the quirks and special ways of doing things and exceptions that make a Query language hard to learn.
These “quirks” also tend to make a query language hard to implement and hard to make fast, because the database has to handle all of these weird things that it does. Suneido lets you define views of your database, that can be basically any query. Something that SQL doesn’t allow in general is being able to update those views. This is just one particular area where Suneido improves on most other systems.
Sparrow: What is “Intelligent Query Optimization?”
McKinlay: Once you query the database and ask for certain information, generally if the query is at all complicated, there’s more than one way that the system can access that data. For example, using different indexes or doing the query in different order or sorting certain files or not sorting them, or creating temporary indexes. This all goes on behind the scenes to make the query run faster. Suneido does a lot of that. It looks at the sizes of all the files, records and indexes. It looks at every different way that it can to implement that query and then it picks the best way to do it.
Again, one of the reasons that it can do a lot of those things is that the query language is very systematic, very simple and straightforward. It makes it much easier to optimize the queries. The benefit is that querying is much faster than it would be with a less intelligent implementation.
Sparrow: What are “Updateable Views”?
McKinlay: A “view” is being able to define a “virtual file” within your database. For instance you might have a file of all your customers, but for a certain use, you might only want the customers that are in Seattle, or the customers that have purchased something in the last 6 months and so-on. You can define a view – a window into that customer file that would only show you certain information. And then you can treat that view just as if it was a file in the system. You can go in and update it and report on it, or whatever else you wish to do with it.
But views can also combine several files. You might decide to physically split the customers and keep a separate file for customers in each city. But then in another place in your program you want to deal with all of the customers regardless of which city they are in. You could define a view that would combine all of those separate files so that the program doesn’t have to know that they were stored in separate files. You could just treat them as if it was all in one file. That provides what’s known as a logical view of the database vs. a physical view. You can change how the files or tables are physically stored in the data base, split them up, combine them, move fields from one table to another, and then define views that don’t change so your programs that use these views don’t have to change every time you change the structure of your data base. That’s pretty important, because changes to the database are quite common.
It’s one of the most common kinds of changes that come up and if all your programs are accessing the database at a physical level – then every time the data changes, you’ve got to change all your programs. Whereas, if they access it through views that you define, then you can just update those views to appear the same – so it looks to them that nothing has changed. Which means you need to change your programs far less often.
Sparrow: Will you explain the meaning of “Built-in foreign key support, including cascade?”
McKinlay: This is a relatively standard, but important feature. A foreign key is where one table refers to another one. For example – a table of invoices would refer to the customer that each invoice applies to. You would tell the database that on the invoice, the customer has to exist in the customer file. It would do a couple of things for you: It would enforce that – it wouldn’t let you enter data that didn’t hold for it and it wouldn’t let you create an invoice for a non-existent customer. It can also stop you from messing it up down the road. If you’ve got invoices for a customer it will stop you from removing that customer from the system.
As well as blocking those types of references, you also have the option of having them cascade. For example, if you’ve got an invoice header and it’s got a bunch of line items associated with it, when you delete the header, you also want the line items to be deleted. Obviously you can write code to do that, but since the database already knows that those line items are attached to the header, if you tell it to cascade the deletes, it will automatically delete the line items whenever you delete the invoice. Or you can also cascade updates so that, for example, if you change the customer’s name, you want it to change on all the invoices that refer to that customer. So again, all those things are things that you could program manually, but it’s a whole bunch of code and again it’s something that’s easy to get wrong or to miss in one place or another. Whereas if the database has information about the foreign keys it can then support that all automatically without having to write any code.
Sparrow: What are “Summary and History Triggers”?
McKinlay: A data base trigger is something that’s done automatically when certain things happen within the database. In this case summary triggers let Suneido maintain summary information that it’s updated automatically whenever the underlying file or table is changed. So, for example, you might want to track your total sales by city and by salesmen. You would set up a summary trigger and then Suneido will automatically maintain that information for you. Likewise the history trigger will automatically keep track of all the old versions of records that you’ve changed. One thing that is crucial in a lot of business systems is maintaining a complete audit trail. Again, with Suneido, the database will do this automatically for you by keeping track of all of the old versions of records. If you want to see when something was changed or what it was changed to or from, you’ve got a complete record maintained automatically.
Sparrow: And “Business Rules”?
McKinlay: Business rules are the logic, the behavior of your application. For example how taxes are calculated, or how sales are recorded or how things are posted to the General Ledger – all those kind of things. In a lot of systems those business rules exist, but they’re tangled up in a lot of other areas. In terms of say, validation of input, those business rules will all be mixed in with your user interface codes. So you’ve got information on how to calculate an invoice total mixed in with information on how to draw the screen and where to display it, that kind of thing.
You might have the business rules mixed in with your reporting. Again, a report, for example, may have to calculate the invoice total to print it, so it’s got a bunch of code mixed in there, combined with formatting and layout and all kinds of other stuff. The problem with that is that you end up with that code scattered all over the place and generally with it duplicated in a lot of places. Business rules are one of the things that are changed quite often. You might need to calculate taxes differently. If you’ve got that code scattered all over the place, in various reports, on various screens, it becomes a real problem to update. Business rules solve this by extracting all of that business logic out of the reports and out of the screens and putting it in one place, separate from the user interface and reporting, and having them draw on those business rules. That means if you’ve got to change something, such as how the invoice total is calculated or how the taxes are calculated, you only have to change it in one place and all your reports and all your screens will reflect that change. It also means you’re writing a lot less code when you are writing reports or user interfaces, because you’re not writing that business logic every time.
Sparrow: How is that different from building standard functions or objects, and inheriting the changes?
McKinlay: Usually the business rules are at a lower level than the objects. One object might end up using a lot of different business rules, and one function within an object might be drawing on a lot of different business rules. It does attack some similar problems, but it is problems that inheritance and the Object-Oriented stuff don’t really handle. It’s at a different level from what they’re tackling. Again, with Suneido, because of its tight integration, those business rules carry through in the database, in the user interface and in the reporting.
There are other systems that support business rules. They might support it in the language, but then you’re getting somebody else’s database, so then they are not supported in the database. Or it might be supported in the database, but not in the language, so it’s not complete coverage, which really negates a lot of benefits. The whole point of having Business Rules, is to have that logic in one place, useable by the entire system. Unless the system is completely integrated, you don’t really get the true benefits of that.
Sparrow: How about “Crash Recovery”?
McKinlay: That ties in fairly closely with the transaction processing and the concurrency handling. It means that if the system crashes you want to be assured that that you’re not going to lose a lot of data.
Probably even more importantly, you can handle a data loss by doing backups and things like that, but first you have to know whether the data is valid or not. A lot of systems don’t have very good ways of detecting problems, so you might crash and come back up and think that everything is fine, so you don’t use your back-ups and then a month down the road you find out that you lost a whole bunch of data, or that a bunch of data was corrupted. By then you can’t go back to your back-ups, it’s too late. Suneido does a lot of careful checking so that when it does come back up after a crash, it makes sure that everything is intact.
The other issue is whether the data is consistent. Going back to our example of moving money from one account to another, if you crash in the middle of that, when it comes back up, you want to be assured that either the money is going to still be in the original account or it’s going to be in the final account. Not that it’s gone missing or that it ends up in both accounts. That kind of consistency is really important. Basically Suneido makes sure that if there are problems, if the data does get corrupted, it guarantees that any transactions will either be done entirely, finished correctly or they won’t be done at all. So they won’t ever have partially completed transactions.
Sparrow: Suneido provides for “On-Line Back-Ups”. Can you tell us about that?
McKinlay: A lot of systems can’t make back-ups while the program is running. So you’ve got to get all your users out of the system and shut it down totally before you can make a back-up. But with Suneido’s database, it can be continually making back-ups. It can make back-ups in the background. That has a lot of advantages. That means you can make back-ups more regularly, or update them more regularly, because you’re not being forced to kick everyone out. Often it’s just not practical to shut down the whole system in operations that run twenty-four hours a day or run multiple shifts. There are always people using the system and you don’t want to have to shut it down. What usually happens is that they don’t make very good back-ups and that’s obviously potentially disastrous.
Sparrow: You talk about providing “user interface and reporting frameworks, with access to all standard windows controls”. Does that need any explanation?
McKinlay: Some systems make themselves simple by only providing a restrictive set of controls, or a limited set of functions. This is fine until you need something that they don’t provide and then you’re stuck. Suneido is more open-ended in that you could quite easily use almost anything that comes along and add it into the framework quite easily.
Sparrow: And the ability to define new controls?
McKinlay: Again, a lot of systems have a limited restrictive set of abilities and they’re not extendable. You are stuck with what they provide. With Suneido, if there is something missing or something you want handled differently, you can add it. Including the source code for all of the standard framework means it’s quite easy to see how things are done, go in and modify them or tailor versions of them to suit your needs.
Sparrow: We talked about comparisons to these languages, but what about the database? There are a lot of data base products out there. How does this database compare to some of the industry standards?
McKinlay: It’s comparable to most of the full database products such as Oracle, Sybase and so on. One of the biggest differences is the tight integration with Suneido’s language, which obviously the other products lack. As far as the query language, most of the standard database products use SQL and it has a lot of drawbacks. These products are forced to do that because they are trying to maintain compatibility with other languages and other products. Because Suneido is an integrated system, it’s not forced to be backwards compatible, in that way. So we’ve got more freedom to provide a much better solution than they can with the query language.
Suneido also has some advantages in the concurrency areas. Traditionally it was thought that full concurrency control, the properly handling of transactions, was too expensive performance-wise. Even though it’s really not true these days, a lot of systems default to not protecting you totally from concurrent access. A lot of people don’t realize this until they start looking closely. That means that a lot of them are wide open to problems, like people seeing inconsistent views of the information.
Although most database systems now provide options to handle the concurrency better, a lot of people don’t know to turn them on or off, or understand what it means to them. Suneido just does it correctly all the time. It’s automatic, you can’t turn it off, and you can’t make it behave wrongly or give inconsistent views of the information. Again, if you are doing rapid development of applications, you don’t want that kind of trap door waiting to fall through. You want those kind of holes plugged for you.
Sparrow: How do you categorize Suneido? Is it a language, is it an integrated development environment, is it a database? What is it?
McKinlay: It’s all of those things. There isn’t really a standard term for it because there aren’t really a lot of products like it. Most other products have a primary orientation, for example it might be primarily a database although it may include a language or might have some user interface tools. Or it’s primarily a language, although it might have some other add-ons. Suneido is a much more complete, balanced system, so it isn’t accurate to call it a database by itself, it’s not accurate to call it “just a language”. It’s an integrated application platform.
Sparrow: Being provided with an Open Source license, Suneido will be available to anyone who wants to download it for free. But what other types of products or services can you provide to Suneido users?
McKinlay: We will be providing manuals, books, CD’s, libraries of code, training, complete applications, support services, add-on tools for the environment – for example for source code control or refactoring or metrics – those kind of things. The sort of add-ons that we can support. We will also provide add-ons for multi-user development, like development in teams in terms of communications. We can provide extensions to Suneido, like Internet extensions for writing web applications and things like that. These are just some of the potential things we can provide.
Sparrow: How would Suneido function as a language of development for application service providers or for development of web applications?
McKinlay: It depends how you interpret those terms. A lot of people use the term web application, when they really just mean something that runs across the Internet. The web is just one portion of the Internet. A lot of people are trying to run their applications on the web, by using a browser as the client. The thinking there is that everybody’s got a browser, they’ve all got Internet Explorer or they’ve got Netscape. That is the direction that Java has gone. If you run Java applications across the Internet, you are using the browser as your front-end. The problem with that is that browsers were never really designed to be front-ends for applications, they were designed to view web pages so they are trying to make them do something they were never meant to do.
The other problem is that, although they are supposed to be standard, everybody’s browsers are different – and intentionally so. Microsoft adds extensions to its browser to differentiate itself, and Netscape does the same thing. Although the idea was that if you had a web application you could run it anywhere you have a browser, the fact is because of all their differences, it’s virtually impossible to make something that will run on more than one browser. That negates a lot of the benefits. It makes for quite rudimentary user interfaces. So that’s their weakness.
If you generalize it to just running across the Internet, which is really what most customers want, they don’t care whether it’s on the web or not they just want to be able to run it across the Internet. That’s where Suneido could definitely be useful, because it’s client server. Using Suneido as the client instead of trying to use a browser means you are using something for what it was designed for. It was made to build user interfaces, which means you can have a lot better interaction. It’s easier to interface, there’s a lot better feed-back, and there are far more elaborate and powerful user interfaces. So definitely it could play a role there.