I work at Portus, and can speak a bit for some of these issues.
Portus Group is an official reseller of Artisoft's Televantage. However, Portus also has a telephony and IVR platfor called PortusConnect, first implemented on Linux, and then ported to the Win32 platform.
Portus's PortusConnect is analogous to Emacs. It's a completely programmable telephony application, written entirely in Common Lisp, and has a CL interface as well. It's client-server based, so you can run the hardware part of the system in one place, and control is completely elsewhere.
We chose to resell Televantage because after researching the alternatives, we felt that it was the best and most open and feature-rich product.
In the process of selecting products, we considered the following:
o Altigen (similar product to Televantage)
o Vertical Networks
o Shoreline
o OpenPBX (from VoiceTrix)
o up-coming open-source PBX from Bayonne
o Cisco
o Interactive Intelligence
o Alcatel's OmniPBX (expensive!)
We did some heavy research, and really liked some of them. I like the overall idea of what Vertical Networks is trying to do with their InstantOffice system. I also think that Altigen has a great product. However, there were features that were missing from these (I can go on and on about them). Also, I wanted something that could handle everything from a small office, with a handful of people, to a large call center. I wanted something that was well integrated with standard products out there. I also wanted something (here's the key) with a nice web-based client interface (Televantage wins here).
Our own product, PortusConnect, is completely compatible with Televantage, and we will soon be integrating the two, so that you can use PortusConnect for your very fancy IVR applications (with a nice database interface, text-to-speech interface, etc.) as well as its embedded Lisp-based programming language.
Televantage supports VoIP, call conferencing, voicemail screening and barge-in, call supervision, recording, coaching, and much more. It's based on open standards (Intel/Dialogic boards).
The fact that it's written for Windows is a good thing, since the drivers under Windows are more stable.
Portus Group (http://portusgroup.com) generally gears its products towards the Linux market, but tries to keep things portable to Win32 by using Common Lisp (CL). CL isn't like Java, but it's got the main operating systems down:
o Linux
o Solaris
o Win32
o Mac OS X
and so we're happy. CL also seems to run significantly faster than Java.
If anyone has even used the strokes-mode in (X)Emacs, I have taken that to the X level by writing what is a higher-level application of gesture recognition. Consider this:
Why should each application implement gestures differently? For example WM commands (close, kill, iconify, maximize, resize, etc.) apply to all windows. Then, within each application, you might imagine some application-specific gestures. This can all be done at the X level. I decided to take the elisp code that's been doing gestures in (X)Emacs since '97 and ported it to Common Lisp (using GNU CLISP). This implementation if CL is GPL'd, and has an implementation of Xlib (called CLX) that plugs right in.
Anyway, CLISP is just about as portable as gcc is, so the same goes for the CL version of strokes.
What I havn't done, though, is to build a nice GUI for editing all the different strokes bindings for all the applications.
I've been playing with the idea of releasing this for years so that people could control all their applications using gestures. I figured that someone probably has done this (though probably not in Lisp, which is a shame).
Both Emacs and XEmacs have `strokes-mode' which works pretty well, and which (in XEmacs) is highly graphical. You can just do:
M-x strokes-mode
and then go nuts.
I think:
http://mit.edu/cadet/www/strokes-help.html
will help if you have trouble figuring out how to use this mode. But it's very easy. The basic premise of strokes-mode in (X)Emacs is that 3-button mice don't have any usage assigned to *dragging* the middle mouse button. So strokes-mode uses that for gestures, and it works well. Moreover, you can easily define your own new strokes, and assign them to whatever commands you want, just like:
If you look at the strokes package in XEmacs, then you'll see some support for Chinese characters. You can enter them in graphically with a pointer device (e.g. mouse, tablet, etc.) and then if you want, you can run a chinese character recognition program on them. At least, that's what I've done. I use an HMM (hidden Markov model) for analyzing the data. Unfortunately, there are on the order of 10k chinese characters, of which I've done about 1%. At some point, it would be nice to get character data from volunteers. Then all you'd need to do Chinese graphically on Linux would be XEmacs.
as rgristroph mentioned, Common Lisp (CL) is an excellent language for code generation. Most developers are not capable of writing compilers, but CL is the only langage I know of that lets you come close (actually, it lets you go the whole way, pretty much).
Every language has its strong points. I think the strong points of CL, _some_ of which were mentioned, are (in no particular order):
1) access to all CL functionality at compile-time
2) the code itself is data, stored in basic Lisp
data structures (lists, atoms).
3) ability to write code-generating macros
using (1) and (2)
4) no _required_ type declarations
5) massively dynamic
6) very powerful object system, also completely
dynamic
7) integrated compiler/debugger/read-eval-print
loop and development system (that's a simple
but powerful command-line evaluator)
8) friendly and helpful community of CL
programmers
9) several free implementations
10) ANSI standardized
11) no pointers
12) automatic garbage collection
13) platform- and implementation-independent code
for the most part (except sockets, and some
other stuff)
actually, there's more, but it just goes on and on. I hit the most salient features, I think.
As a common lisp user and developer I confirm that many of the most important language features are available in CL, and are done right. I constantly see CL language features be done (and wrong) in lots of other languages, including (but not limited to C#). Java sucks, C of course sucks, and C++ is just a disaster. Dylan has some features, but just sold out half-way, and only works on MS, and has an unappealing syntax, limitations that make it not worthwhile, and is just a 2nd-rate rip-off of CL.
Slashdot Mirror
I work at Portus, and can speak a bit for some of these issues.
Portus Group is an official reseller of Artisoft's Televantage. However, Portus also has a telephony and IVR platfor called PortusConnect, first implemented on Linux, and then ported to the Win32 platform.
Portus's PortusConnect is analogous to Emacs. It's a completely programmable telephony application, written entirely in Common Lisp, and has a CL interface as well. It's client-server based, so you can run the hardware part of the system in one place, and control is completely elsewhere.
We chose to resell Televantage because after researching the alternatives, we felt that it was the best and most open and feature-rich product.
In the process of selecting products, we considered the following:
o Altigen (similar product to Televantage)
o Vertical Networks
o Shoreline
o OpenPBX (from VoiceTrix)
o up-coming open-source PBX from Bayonne
o Cisco
o Interactive Intelligence
o Alcatel's OmniPBX (expensive!)
We did some heavy research, and really liked some of them. I like the overall idea of what Vertical Networks is trying to do with their InstantOffice system. I also think that Altigen has a great product. However, there were features that were missing from these (I can go on and on about them). Also, I wanted something that could handle everything from a small office, with a handful of people, to a large call center. I wanted something that was well integrated with standard products out there. I also wanted something (here's the key) with a nice web-based client interface (Televantage wins here).
Our own product, PortusConnect, is completely compatible with Televantage, and we will soon be integrating the two, so that you can use PortusConnect for your very fancy IVR applications (with a nice database interface, text-to-speech interface, etc.) as well as its embedded Lisp-based programming language.
Televantage supports VoIP, call conferencing, voicemail screening and barge-in, call supervision, recording, coaching, and much more. It's based on open standards (Intel/Dialogic boards).
The fact that it's written for Windows is a good thing, since the drivers under Windows are more stable.
Portus Group (http://portusgroup.com) generally gears its products towards the Linux market, but tries to keep things portable to Win32 by using Common Lisp (CL). CL isn't like Java, but it's got the main operating systems down:
o Linux
o Solaris
o Win32
o Mac OS X
and so we're happy. CL also seems to run significantly faster than Java.
good luck,
dave
send email to: cadet@alum.mit.edu
--dave
hey,
If anyone has even used the strokes-mode in (X)Emacs, I have taken that to the X level by writing what is a higher-level application of gesture recognition. Consider this:
Why should each application implement gestures differently? For example WM commands (close, kill, iconify, maximize, resize, etc.) apply to all windows. Then, within each application, you might imagine some application-specific gestures. This can all be done at the X level. I decided to take the elisp code that's been doing gestures in (X)Emacs since '97 and ported it to Common Lisp (using GNU CLISP). This implementation if CL is GPL'd, and has an implementation of Xlib (called CLX) that plugs right in.
Anyway, CLISP is just about as portable as gcc is, so the same goes for the CL version of strokes.
What I havn't done, though, is to build a nice GUI for editing all the different strokes bindings for all the applications.
I've been playing with the idea of releasing this for years so that people could control all their applications using gestures. I figured that someone probably has done this (though probably not in Lisp, which is a shame).
Are people interested in X-level gestures?
dave
hey,
Both Emacs and XEmacs have `strokes-mode' which works pretty well, and which (in XEmacs) is highly graphical. You can just do:
M-x strokes-mode
and then go nuts.
I think:
http://mit.edu/cadet/www/strokes-help.html
will help if you have trouble figuring out how to use this mode. But it's very easy. The basic premise of strokes-mode in (X)Emacs is that 3-button mice don't have any usage assigned to *dragging* the middle mouse button. So strokes-mode uses that for gestures, and it works well. Moreover, you can easily define your own new strokes, and assign them to whatever commands you want, just like:
M-x global-set-key
--dave
If you look at the strokes package in XEmacs, then you'll see some support for Chinese characters. You can enter them in graphically with a pointer device (e.g. mouse, tablet, etc.) and then if you want, you can run a chinese character recognition program on them. At least, that's what I've done. I use an HMM (hidden Markov model) for analyzing the data. Unfortunately, there are on the order of 10k chinese characters, of which I've done about 1%. At some point, it would be nice to get character data from volunteers. Then all you'd need to do Chinese graphically on Linux would be XEmacs.
dave
as rgristroph mentioned, Common Lisp (CL) is an excellent language for code generation. Most developers are not capable of writing compilers, but CL is the only langage I know of that lets you come close (actually, it lets you go the whole way, pretty much). Every language has its strong points. I think the strong points of CL, _some_ of which were mentioned, are (in no particular order):
1) access to all CL functionality at compile-time
2) the code itself is data, stored in basic Lisp data structures (lists, atoms).
3) ability to write code-generating macros using (1) and (2)
4) no _required_ type declarations
5) massively dynamic
6) very powerful object system, also completely dynamic
7) integrated compiler/debugger/read-eval-print loop and development system (that's a simple but powerful command-line evaluator)
8) friendly and helpful community of CL programmers
9) several free implementations
10) ANSI standardized
11) no pointers
12) automatic garbage collection
13) platform- and implementation-independent code for the most part (except sockets, and some other stuff)
actually, there's more, but it just goes on and on. I hit the most salient features, I think. As a common lisp user and developer I confirm that many of the most important language features are available in CL, and are done right. I constantly see CL language features be done (and wrong) in lots of other languages, including (but not limited to C#). Java sucks, C of course sucks, and C++ is just a disaster. Dylan has some features, but just sold out half-way, and only works on MS, and has an unappealing syntax, limitations that make it not worthwhile, and is just a 2nd-rate rip-off of CL.