Geertjan is a DZone Zone Leader and has posted 457 posts at DZone. You can read more from them at their website. View Full User Profile

Interview: John De Goes Introduces a Newly Free Source Code Editor

06.09.2008
| 96174 views |
  • submit to reddit
You announced last week that UNA Personal Edition is now being distributed for free. How did that happen?

UNA Personal Edition exists as a byproduct of UNA Collaborative Edition. Last year, we realized that our networking layer (itself the result of two years of experimentation and refinement) was sufficiently abstracted that we could trivially produce a network-less plug-in, which would enable the server to run in the same JVM as the client, shuffling events around entirely in memory. At the same time, I was doing a lot of work on the road and really wanted a way to use UNA without having an Internet connection.

About a month later, UNA Personal Edition was born, packing all the non-collaborative features of UNA into a version that doesn't require a server or an Internet connection. Otherwise, it's feature-for-feature identical to UNA Collaborative Edition, even allowing you to add users, draw on the whiteboard, and chat to yourself.

We never intended Personal Edition to be free. Years of work and cutting-edge research went into this editor, and it rivals, even surpasses, commercial editors that are selling for $100, $200, even $400 a pop. Even though it wasn't our primary goal, we realized that we produced a standalone editor of great value, and we hoped to use Personal Edition to subsidize some of the costs of developing UNA.

Unfortunately for us, that wasn't meant to be. The tools market is dead. Open source killed it. The only commercial development tools that can survive today are the ones that leapfrog open source tools. With UNA Collaborative Edition, we have that—there's nothing for real-time collaborative development that even comes close, whether commercial or open source. But UNA Personal Edition is more of an incremental improvement on what's out there in the editing world.

UNA Personal Edition was not going to persuade Java developers to stop using Eclipse or Idea, .NET developers to stop using Visual Studio, Ruby developers to stop using TextMate, or die-hard Emacs and Vi developers from using those respective editors. Why? Because stripped of its collaborative features, what remains is an incremental improvement on the status quo. Incremental improvements that cost money don't fare well against free tools. Especially not in the context of a developer tool, which is a very personal issue to many. Some developers would rather quit their job than be forced to use a new editor or IDE.

So I think we've slowly come to the realization that in order to gain widespread acceptance, UNA Personal Edition has to be free—not free just for version 1.0, but free for all versions, for all time. We will never charge a penny for UNA Personal Edition. Now it can compete with all the other free stuff out there. Sure, it's an incremental improvement on what many people are using today—but it has some features you're not likely to see anytime soon in either free or commercial editors, and it's getting better every day.

Ironic, the way it turned out: UNA Collaborative Edition now subsidizes Personal Edition!

How does it compare to Eclipse, NetBeans IDE, and IntelliJ?

First of all, I should mention that UNA is a source code editor, not an IDE. It's a very sophisticated editor, well on the road to becoming an IDE, but it doesn't provide out-of-the-box support for compiling, testing, or debugging. However, you can add those features to UNA by using the external tools interface, which allows you to do all these things from inside UNA. The tools interface is, bar none, the most powerful interface for integrating with external tools that we know about.



Now, although setting up external tools takes less than 10 minutes for the average project, it's the single largest barrier to entry because the majority of today's developers don't know how to invoke tools from the command-line. The fantastic IDEs we have today have shielded developers from the workings of compilers and testing frameworks. This is wonderful, in that it's brought many people into the field who would not otherwise be in it. It's lowered the cost of entry. But it's not so great for tools like UNA, which assume that developers are familiar with such things. We have plans to dumb this down, to make UNA more accessible to the average developer, because we realize this is a growing segment we can't ignore.

All that said, I think UNA fares very well against Eclipse, NetBeans, and IntelliJ Idea.

  • First of all, we're usability snobs, and I mean that in a good way. We've poured extreme attention to detail in building the user-interface of UNA. We routinely conduct usability tests to refine the product. And because of all this, we've built one of the most usable development environments out there. We have usability tests showing that a user who knows nothing about UNA can download and install the product, and write and compile a Hello World program in about 10 minutes. This is with absolutely no help from us and no user manual or reference of any kind. Ask a user who knows nothing about Eclipse to do the same, and you're looking at a timeframe measured in hours. Much less time for NetBeans or Idea, but still not as good as 10 minutes.

  • We've taken great care to ensure that UNA's interface is non-modal, wherever possible. For example, every document and text box in UNA operates in the exact same way—auto-complete and incremental search work alike in both. Similarly, you can search any list or tree in the exact same way, regardless of where it's located in the program. These features let you forget about where you are in the interface and work in a uniform way. This may seem like a small thing, but it's really not. I can't count the number of times I've cursed the editor or IDE I was using because some operation that worked in one place simply refused to work somewhere else.

  • UNA doesn't use pop up dialogs that force users to hit 'OK'. If modality is the number one enemy of usability, then pop up dialogs must be enemy number two. How many times have you filled in a dialog, and clicked 'OK', only to be informed you entered invalid data and must try again? If you're like me, hundreds of times. Most applications punish users for entering data that they allow the users to enter. They bash users over the head, effectively telling them, 'You stupid user, why did you enter such stupid information? Go try again!' In our view, it's not the user who is stupid, it's the application: applications should never punish users for entering data they allowed the users to enter. This philosophy is evident everywhere in UNA. For example, if you go to create a new class, but type in the name of an existing class, then as soon as you type that last letter, the OK button becomes disabled and an unobtrusive message appears on the same dialog to let you know that a file of the same name already exists. Similarly, if you create a new tool, but forget to specify the tool executable, the OK button is disabled, and displayed on the same dialog is a helpful little message explaining why you can't hit OK just yet. You won't find this obsessive attention to usability in any other IDE or editor (no one is as crazy as we are!).

  • Keystrokes are another strength for UNA. We follow a set of rules: if you want to expand the scope of an operation, you hold down the 'Shift' key while invoking the operation. If you want to perform the interactive or expanded version of an operation, you hold down the 'Alt' key while invoking the operation. And if you want to do the opposite of an operation, you tap or hold down the 'Caps Lock' key while invoking the operation. Now, without any further hints, if Ctrl + S saves the current file, what does Shift + Ctrl + S do? What does Alt + Ctrl + S do? If Ctrl + O opens a file, what does Caps Lock + Ctrl + O do? You already know the answer to these questions because you know the rules. Developers have better things to do with their time than memorize keystrokes. Some of the above mentioned IDEs even go against the conventions of the underlying operating system—and as a Mac user, this drives me crazy. Applications, especially editors and IDEs, should respect the universal conventions of the underlying operating system, so users don't have to learn separate keystrokes for performing the same basic operations in different applications.

  • Another standout feature in UNA is the non-blocking interface. Whenever you initiate an operation, it happens in the background. You're free to continue working while the operation completes. I suspect many developers like myself are tired of waiting for today's heavyweight IDEs to finish some operation, whether it's updating a project or running unit tests. UNA lets you work instead of wait. This is much more difficult to code, because it means UNA is massively multithreaded, capable of taking advantage of all the processing power you can throw at it. But the result is a more pleasant user experience.

  • I would also say the search/replace and incremental search interfaces far surpass those in Eclipse, NetBeans, and IntelliJ Idea. I love IntelliJ Idea, but I can't count the number of separate Find and/or Replace dialogs that it has. Every time I open that menu I spend 10 seconds trying to sort through the mass of options I see. UNA has a single Search and Replace interface, which is non-modal and doesn't interfere with your editing of text. You can save search queries if you use some options repeatedly, and access them with a keystroke. But the basic interface is perfect because you don't have to think. You can literally do everything from a single interface. And did I mention that searches are instant, even if the project contains hundreds of files? The incremental search in UNA is so novel that we're patenting it. That's right, we're patenting a feature we're giving away for free. The incremental search interface allows you to navigate documents with theoretical maximum efficiency. You can jump to wherever you want in the document by typing just half a keystroke more than the minimum number of characters necessary to differentiate that position from others. You can't do better than that. People were blown away by the incremental search feature of Idea 7.0, but we've got something better than that.

  • Finally, I think that the process of building, testing, and running complex projects is becoming something that can't be done natively by any IDE, but which requires a full-fledged build language such as Maven, Ant, SCons, etc. With cross-language development increasingly common, development environments that can handle any language, and which rely on external tools for building, are becoming more and more relevant. If you have 10 languages to support, then you're already going to be doing so much work outside the IDE, that UNA is a stronger contender. For example, if you're writing a project that is a combination of C and Java (perhaps even Jeannie), then your IDE with great support for just Java is not going to be as useful as a tool like UNA, which provides good support for both. In either case, you're going to be building, testing, and deploying the project with scripts or programs external to the IDE.

In summary, as long as you're aware that UNA will require some effort to get your project up and running, UNA Personal Edition is a great choice for software development. UNA far surpasses existing tools on grounds of usability, and includes features that just aren't available anywhere else. Will it replace your favorite Java IDE? Probably not right now, but it will do a fine job complementing that IDE, especially in mixed language environments. And you might just find yourself wishing your IDE was more like UNA, because no tool pays as much attention to you as UNA, nor works as hard as UNA to stay out of your way.

AttachmentSize
version-control.png92.85 KB
una-screenshot.png132.84 KB
tools-interface2.png102.52 KB
tool-interface.png87.26 KB
source-snippets2.png163.01 KB
source-snippets.png96.27 KB
smart-autocomplete.png175.84 KB
Save search queries for later.png13.17 KB
right-click-tools.png182.52 KB
Quickly navigate UNA without using a mouse.png15.91 KB
Quickly navigate documents with incremental search.png5.45 KB
Quickly locate symbols, files, declarations of symbols.png15.17 KB
One search and replace interface - unlimited power.png5.61 KB
jump-to-symbol.png163.57 KB
java-extensions.png168.28 KB
file-templates.png57.95 KB
file-templates2.png92.71 KB
instant-search.png163.06 KB
johndg.png70.47 KB
johndg.png26.37 KB
Published at DZone with permission of its author, Geertjan Wielenga.

Comments

Mike Miller replied on Mon, 2008/06/09 - 2:13pm

Sounds nice but couldn't get it to start - all I see is the interesting splash page and the client never starts.

Geertjan Wielenga replied on Mon, 2008/06/09 - 2:45pm

I've just installed it (on Linux Ubuntu) for the first time. Between the time that I clicked the download link and had the app up and running, I was approximately 2 minutes older.

Andrew McVeigh replied on Mon, 2008/06/09 - 3:06pm

It's a great looking editor, and it's fantastic to see new tools and innovation in the editor space. I wonder though about the "free single user" play though. When I started it up, I realised I couldn't collaborate with anyone and I lost interest. I wonder if a "free" mode with limited collaboration (or limited connectivity) is going to be more effective as a tactic for getting people interested.

Cheers,
Andrew

Andrey Kuznetsov replied on Mon, 2008/06/09 - 6:52pm

It does not work.

Here is the console output:

C:\Program Files\UNA-1.0>java -jar unaclient.jar
10.06.2008 01:37:57 net.nbrain.una.unaserver.database.L E
INFO: DatabaseHomeDirectory = C:\Users\andrey\.UNA\\server-personal\database\
java.util.logging.ErrorManager: 2Handler.reportError caught:10.06.2008 01:37:58
net.nbrain.una.unaserver.database.I E
SCHWERWIEGEND: java.lang.NullPointerException
java.lang.NullPointerException
10.06.2008 01:37:58 net.nbrain.una.demo.J$A run
SCHWERWIEGEND: Can't start application: null
java.lang.NullPointerException
at net.nbrException in thread "AWT-Ev

 

Geertjan Wielenga replied on Tue, 2008/06/10 - 4:04am

Maybe it can't handle the space in the name between "Program" and "Files"? I don't know, just guessing.

Mike Miller replied on Tue, 2008/06/10 - 9:09am in response to: Mike Miller

My setup is a bit different - JAVA_HOME points to a 1.4.2_X version because our product is 1.4 but my JRE is 1.6 so that I can run Europa.  It appears that UNA ships with a 1.5 version of Java.

Tried resetting java home to my 1.6 and still didn't work. Also made sure I was running their shipped version (1.5) but still hangs after the splash screen.

Mike Miller replied on Tue, 2008/06/10 - 9:36am in response to: Geertjan Wielenga

That's not it - they did double quote around the "Program Files" in each instance

Alexander Parshuto replied on Tue, 2008/06/10 - 10:16am

Did you run Una as a root? Do you have access rights to a temp file system? Please make sure that you have access rights on temp file system?

@Andrey Kuznetsov: could you please send full stack trace to support@n-brain.net

thank you in advance.

 

Andrey Kuznetsov replied on Tue, 2008/06/10 - 10:31am

Alexander,

I posted complete console output. I have no idea why output just stopped in the middle.

John De Goes replied on Fri, 2008/06/13 - 8:33am in response to: Andrey Kuznetsov

Hi Andrey,

For some reason, the installer fails to create an appropriate directory (.UNA in your home directory) on some variants of Windows XP. If you download the raw distribution, create a .UNA directory in your home directory (echo %HOMEPATH% to find it), and copy the /syntax/ and /server-personal/ directories to the .UNA directory, then everything should work fine.

Creating the .UNA directory must be done from the command-line, as in every case so far where the installer fails, users cannot create the .UNA directory from Windows Explorer either. 

Our next installers (to be released today or Monday) have a workaround that attempts to address this issue. 

If you have any other questions, feel free to email us at 'support' or use the Community Forums (http://www.n-brain.net/forums/).

Andrey Kuznetsov replied on Sat, 2008/06/14 - 5:03am

Well, in fact installer created .UNA directory. However not in my home directory, but direct under c:\.

 

John De Goes replied on Sat, 2008/06/14 - 10:24am

What does 'echo %HOMEPATH%' say at the command-line prompt?

Andrey Kuznetsov replied on Sat, 2008/06/14 - 2:27pm

\Users\andrey

serena lin replied on Sun, 2009/08/09 - 9:57pm

nice post keep good writing, you will be success, by nike air max 90 running shoe,Link Text

Kookee Gacho replied on Tue, 2012/05/29 - 6:25am

When a Java program is complied, it results is a byte code. A byte code is machine independent. That is, you can take the byte code on a computer w/ any OS, hardware, processor, etc, and run it.-Arthur van der Vant

Dean Schulze replied on Wed, 2012/08/29 - 4:05pm

Any plans to support the Go language?  

Raging Infernoz replied on Sat, 2013/03/30 - 12:30pm

Collaborative IDEs, and pair programming sound pretty similar, but does not seem very Introvert friendly, if used much; this is important, because I bet most developers are Introverts, like myself.

What happened to http://www.n-brain.net/ and UNA?

The domain is on a holding page and the editor seems to have disappeared; the company must have gone bust, so this looks like a zombie article; so I'm astonished this is still listed in Popular Links!

NetBeans just keeps getting better.

Eclipse is a functional and cluttered UI mess, including the regurgitated project structure abominations, it should never have allowed, which make Maven migrations painful; so I avoid using it as much as possible.

Intelli-J is plain too expensive given than NetBeans exists; I only pay for tools which are economically priced or excellent value for money e.g. Directory Opus.

I want nothing to do with collaborative cloud editors, they are a privacy and security nightmares waiting to happen, because they are all-in 'solutions'!

Collaborative projects can need a lot more visibility than just source code, so distributed source control systems, multiple monitors, and selective desktop sharing are far more useful.

Michael Je replied on Fri, 2013/04/05 - 7:42am

 Eclipse is a functional and cluttered UI mess, including the regurgitated project structure abominations, it should never have allowed, which make Maven migrations painful; so I avoid using it as much as possible.

http://babul-ilm.com

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.