Questions:
|
1
|
|
2
|
|
3
|
|
4
|
|
5
|
|
6
|
|
7
|
|
8
|
|
|
Introduction
The software development world today is filled with lots of buzzwords, trends, hypes and bandwagons you have to know or see through, to figure out what a tool-vendor is actually offering. (Object oriented, Virtual Machine, UML, Realtime extensions, code generation etc). It is not easy to figure out what you can actually DO with their tool and how (or if) it is going to help you reaching your development goals. Often you will have to spend serious time on a demo version to get a clue.
As a tool vendor it is easy and tempting to associate your products with these hypes -jump on the bandwagon- and try to get a piece of the action. Try to convince a manager that your product/method is "all saving", sell a couple of training courses on the side and in the end the engineers/programmers have to figure out how to use it.
We are going to try to be straight to YOU engineers by giving you down-to-earth answers on every question in the FAQ below. (Warnings are included for sections which are rich with buzzwords).
The Questions are listed on the left! (Clicking them will navigate you to the answers below)
|
1
|
What is XPad?
A low-cost....
Visual design tool
Visual programmers editor
Animated simulator
Your Word processor
Compiler
For multiple targets
XPad is a free software-development environment, which -when combined with low-cost target-modules- gives a complete visual design, programming, testing, documentation and building suite for small to medium-sized software systems.
Originally, development targeted Realtime Embedded systems for popular 8bit microcontrollers. But since XPad's concepts also apply very well to event-driven user interfaces, small Windows-GUI-based applications are "targeted" as well. Target-modules are planned as well for the growing number of Windows-CE (PocketPC) and PalmOS developers!
|
2
|
What design concepts does XPad use?
(warning: next section contains some buzzwords)
XPad's design-framework includes features borrowed from Yourdon Structured Design Method when applied to realtime control-systems as well as Object Oriented Design features as can be found in Booch's Object Oriented analysis approach. In the used concepts a central role is played by Finite State Automata ("FSA"), more commonly called State Machines -which are specified in State Control Diagrams ("STDs")- or the nowadays overloaded terms "agent" and "object".
The State Machines in XPad promote Object-based design. They are:
Abstract Data Types (ADTs), having:
local (encapsulated) data;
member-functions and
can be instantiated, in case the same control-behavior applies to different sections of the environment;
control the software's environment by explicitly identifying discrete moments in time, resulting in scheduling code optimized to your application!
and are easy to understand/edit!
The states of an object/agent or STD (State Control Diagram) are specified in easy to use flow-diagrams, containing lists of functions. If you are not comfortable with the concepts of objects and states, all you need to know is that an STD is just a special library of functions, which you can connect together:
in a traditional more functional fashion or
in an object-based/event-driven manner.
But more important XPad software models:
are highly recognizable to software engineers and programmers;
are formal, while at the same time their main purpose is to serve as a base for the target-code; and every mouse-click brings you closer to the code. Your keyboard is only used to enter comment for your documentation!
|
3
|
What can XPad do, which I cannot do already in my existing environment?
Answer 1:
You don't need to be fluent in the syntax of a specific programming language. Your design is expressed in 3 types of simple diagrams ( State Diagram, Flow Diagram and Expression sheet) which are intuitive/familiar to anyone who has used a computer before, including your customers and manager. At the bottom level -the blocks in a flow-diagram- you just specify lists of functions you want to be performed.
Answer 2:
You use the mouse for all designing/programming and testing. User-friendly editors only show what is relevant in a particular context. Simple but clear browsers allow you to navigate through your design. Context sensitive help and design Wizards explain what you can do where. Your keyboard is only used to type comments you want to be included in your documentation. Syntax-errors don't exist!
Answer 3:
A formal design document is generated fully automatic. You can indicate the level of detail you require and the result is easy to read, all in less than a minute!
Answer 4:
A (realtime) executive/Operating System is generated automatically from your design. You are designing it yourself without requiring extra effort. A design always contains multiple tasks and you can specify response-times to be as realtime as required and/or supported by the selected target-platform.
Answer 5:
XPad uses plug-in target-modules supporting a growing number of computing-platforms, ranging from small embedded micro controllers to Handheld organizers (including existing API-support).
Answer 6:
The simulator uses an intermediate compile-format which allows you to explore, validate and debug at design-level (you simulate your design-"document") but is close enough to the final target-code to show and prevent implementation-problems early during development.
Answer 7:
Simulator-sessions are used to profile and optimize the code when it is finally generated.
Furthermore XPad is inexpensive and easily expanded to include other targets. The free targets, tutorials, examples and wizards show what XPad can do for you and explain the most important design-constructions. The affordable compiler-modules generate efficient native code. Prompt support from GenerExe engineers helps you out when you encounter a problem or require additional functionality.
|
4
|
Why does XPad use State Control Diagrams (Finite State Machines)?
Why are YOU using them yourself?
We all use STDs constantly! It is the only way to perform multiple tasks which may or may not be synchronized on a single processor. Also multiple processors working on the same task can be synchronized similarly. What about protocol- handshaking? If you have been working with Objects lately you might have seen them as well. The most common STD you might have forgotten about is your operating system's task-scheduler. (Each task is pseudo-execution thread). Remember the last time you analyzed a deadlock situation?
|
5
|
Aren't State Machines a pain to program?
Yes, traditionally they are! To answer this question a quick flashback to software-design history is useful.
Program-code is sequentially organized. If you have to wait, you trust that some OS-kernel pre-empts you to use the processor efficiently but at the same time wakes you up soon enough to keep up the realtime illusion of your sequential piece of code. Most operating systems include communication and synchronization mechanisms to make this process as efficient as possible. Using these mechanisms can be tricky though if you have no clue about HOW the tasks are scheduled. A well-designed cooperative set of tasks work together like a State Machine!
Now, the problem is that -as the word "task" indicates- that the easiest way to understand a program is to read sequentially which functions are performed one after another. (That is the way our own language works as well as our writing and the computers we have created). Our brain has difficulty tracking multiple tasks consciously. Multitasking schedulers helped us out by hiding the parallel mechanisms, allowing us to view the task as a single seemingly uninterrupted piece of code. In the days that functional decomposition ruled as the main method to structure software this was perfect! Our software was a hierarchy of functions and our tasks/threads were in charge. They were the central focus of our design. (The overhead -the OS-mechanisms generated to sustain this view- was a minor price as well as analyzing some difficult to detect bugs related to it, like deadlock, mutual exclusion etc.).
End of story? NO! Increasing performance of processors, size of memory refocussed our attention to the data. It turned out that organizing and maintaining large amounts of data was making it difficult to utilize the new hardware reliably. That is where data-hiding, encapsulation, abstract data types, classes and objects entered the arena! And our long worshipped threads were degraded to just another resource or implementation-mechanism that could be utilized by objects as they wished. With the arrival of objects, the State Machine view was revisited. It turned out that they provided a natural local view on the kind of control dynamic objects require to manage their data. Simple objects only need 1 or 2 states, corresponding with their construction and destruction.
This gives us the following strong arguments for using STDs:
they fit the kind of control needed by abstract data types or objects;
they were there all along. Recognizing them explicitly greatly reduces the overhead needed to "task" them in multitasking environment, resulting in better response times;
new visual tools can make them easy to specify and manage (you are not stuck with the sequential view given by traditional linear programming-languages; diagrams make it easier to grasp the parallel nature of STDs);
they have a very small memory-footprint, making them perfect for software written for small micro controllers. (Some of which barely have a calling-stack).
|
6
|
How does XPad differ from other "design"-tools?
Our engineers have worked with many software design-tools, like TeamWork, Rational Rose, Booch, Yourdon Select, StateMate etc. One thing they all have in common is that they are graphically very fancy, overambitious in what they can achieve, not easy to master and in most cases outrageously expensive.
When you are new to a software-"modeling"-method, it is difficult to decide how much "modeling" is required. Design-tools -which make assumptions about how you should design/implement your software- do not always fit well in with your actual software life-cycle, especially when multiple iterations are required. (Often the models are not updated during the life-cycle iterations; they cannot generate sufficiently optimized code. In the end their main-purpose was to serve as the "as-built" documentation).
Our development of XPad was motivated by the following considerations:
there is no one-to-one (roundtrip) mapping between the output of many design-tools and the final code derived from it;
many design-tools require lots of training for some kind of "all saving" method. The user becomes a subordinate to the method and being overwhelmed by the new "rules" is unable to express his personal experience in the models he creates. (He is treated as a freshman again);
In inexperienced hands, a design-method can be applied "too much", resulting in an output that is not a practical "source" for the final coding-phase. The method became the goal instead of the final product one was working on;
many existing tools focus on the bigger enterprise software systems, leaving embedded software engineers with the same tool-concepts as 20 years ago;
small embedded systems need to be optimized at the lowest level; many tools that are comfortable on this level use the "electronic" metaphor, not fully utilizing potential software-dynamics or providing a programming language, with limited expressiveness, resulting in rather static code; other tools generate code with a heavy footprint or cannot optimize on the required level;
None of these tools are able to generate custom realtime executive/house-keeping code supporting multiple tasks!
ALL OF THESE TOOLS are expensive! (Ranging from a 1000 to 25000 dollars).
XPad attempts to overcome these issues: You will figure out what you are doing in XPad very fast, are not overwhelmed by unfamiliar rules and you are working directly on your final code all the time! Furthermore XPad generates REALTime code and is not another Basic-dialect for a specific kind of processor. Finally, XPad is not expensive, while our Engineers are online to support you with any questions/problems/fixes/updates!
|
7
|
Which targets are/will be supported?
The XPad 1.1 release includes the following targets:
Motorola 68HC11 target. Includes generation of realtime executive and high level interface libraries all in fast assembly code;
PalmOs target (for Palm-Pilots, Visors etc). Includes full GUI-design, serial and database support; generates native executables (prc-resources);
Followed soon by:
Java Target, supporting any platform, which has a JVM; i.e. Dallas Semiconductor TINI embedded controller.
Motorola 68HC12 16bit processors.
Other planned targets, which have no definite specification and release date yet, are:
Intel i188/186
C++/C target
ARM processor target
|
8
|
What are the system-requirements for running XPad?
Any Desktop PC can run XPad:
Pentium processor (Pentium II or higher recommended)
minimum of 64MB of RAM (128MB recommended)
Windows 95, 98, ME or Windows NT/2000/XP
|
Note: XPad's help-file contains more FAQs on how to use XPad as well as design guidelines to get the maximum out of your XPad designs
|