Geertjan is a DZone Zone Leader and has posted 468 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
| 111147 views |
  • submit to reddit

Who are your typical users and what do they say about it?

The typical user of UNA Collaborative Edition consists of between 2 and 10 developers. They're usually distributed, sometimes work in different time zones, often use dynamic languages, and they want a way to get together and collaborate on critical sections in the code.

Since we just released UNA Personal Edition free of charge, we can't say much about the typical user. But since the day we announced UNA, we've seen tens of gigabytes of traffic, mostly from people downloading Personal Edition. So over the coming weeks, we'll be learning a lot about the typical user of the product.

As for feedback, I think we've made believers of any critic who has actually tried the platform. For example, Russell Foltz-Smith of SocialMode fame wrote this unsolicited blurb about UNA Collaborative Edition:

UNA is a special platform. Anyone who knows how I code and run projects understand[s] how bold a statement that is for me. Why? I very much believe in the solo hacking til it works. UNA is about group - real time collab. I usually hate group collab on code and design because the communication and miscommunication gets in the way. UNA is different because the collaboration is weirdly seamless and actually real time - you all see the same things, you chat inline, code completion just works, everything is tracked, and never once does the group feature take precedence over just coding.

...I sure hope the Visual Studio, Netbeans, Eclipse, Zend, Codeworks, and Nusphere folks pay attention to this and either integrate or buy N-brain['s technology]. Seriously, the system is that cool.


Can you share some screenshots of your personal favorite features?

Sure. I'll provide my personal five favorite features of UNA Personal Edition. Several of these are features I use so much, that when I switch to IntelliJ Idea for some solo coding, I mistakenly invoke them.

  • In-place incremental search, which lets me get around documents faster than vi or Emacs users:

     

     

  • A single search and replace interface, no matter what or how I want to search:

     

     

  • Shortcuts that transfer focus to different parts of UNA, so I don't have to use the mouse:

     

     

  • Saving search queries that I use often and accessing them with keystrokes:

     

     

  • Go to Declaration, which I use a hundred times a day to navigate to the declaration of methods and classes:



These are just my favorites. The other developers of UNA have their own favorites, which I'm sure are different from mine.

What exactly do you do when you create new support for a language?

We create a syntax definition file, which is an XML file describing the basic syntactical elements of the language, and how they should be colored. This file also describes the keywords in the language, what constitutes code and what constitutes comments, what token is used to access members of an object, etc. If the language is already supported by CTags, then that's all we do, because our interface to CTags provides a lot of language-aware functionality for free. For languages not supported by CTags, but for which there is customer demand, then in the short term, we will probably contribute parsers to the CTags project.

In the long term, we're in the early stages of developing something similar to the NetBeans language extension API (itself currently in development). This will form the basis for more advanced language-specific functionality, such as semantic analysis and refactoring. The work that's been done in the past few years to unify the parsing and transformation of programs is quite amazing. I think all the major IDEs will move away from the massive amounts of hard coding that brought them to where they are today, and towards more generic platforms that employ language plug-ins—written in domain-specific languages tailored to the task.

Where do you stand, personally, on the place of Java in the language space, i.e., with multiple languages on the VM and polyglot programming and so on?

Java's going to be around for a long, long time. However, It's definitely showing signs of age. When you have to work as hard as some of these frameworks do to make Java development competitive, you know something is fundamentally wrong with the language. XML configuration files, dynamic proxy generation, aspect-oriented frameworks—they're all signs that Java is lacking the expressive power demanded by today's applications.

I could be wrong, but I think the Java community will continue to bolt new features onto the language in an effort to keep up with everyone else, which will turn Java into the next C++. There will be so many ways of doing things (closures or anonymous classes?), so much complexity in the grammar, that most developers working in Java will stick to a subset, while the larger community will move to other languages. Only unlike C++, the move to other languages will be facilitated by the JVM, which may turn out to have a larger impact on software development than Java itself.

Polyglot programming is not new, and a classic example is C and C++. Companies didn't have to abandon their existing code to move to C++ for new development. That's the key to Scala, Groovy, JRuby, JPython, and the other 20 different languages that now run directly on the JVM. They can all seamlessly reuse tens of millions of lines of code written in Java—all the libraries out there that have made Java so powerful, and any code that companies themselves maintain. This makes the language landscape far more competitive than it's ever been in the past. Language lock-in is less of an issue now, in the growing family of languages that run on the JVM.

Of course, there's a cost to maintaining code bases written in many different languages. You need to hire a different class of developer, and that costs more money. Most developers are also resistant to learning and using multiple languages (one developer I know maintains, "Java for life!"). So I think it will be difficult to move the broader market into routine use of multiple general-purpose languages.

I do expect that we'll see a kind of meta language in the next 5 years that a competent developer can use to construct domain-specific languages (please don't anyone say Lisp!). Ruby has had success in this area even though it was never designed with this goal in mind. Some Java and Flex developers are using Ruby to construct DSLs to perform automating testing and building. Who could have predicted that?

What's UNA's future direction?

Everything we do is motivated by the vision of bringing developers together, to collaborate in ways the development world has never seen before. So you can expect lots more in this direction—features I'd rather not discuss just yet, but which can only be built on top of a collaborative platform like UNA.

A lot of the other new features coming to UNA will also benefit Personal Edition users. For example: Live syntax checking for most languages. A new concept we're calling 'project mixins', which let you add chunks of functionality to a project (for example, a full suite of tools for compiling, testing, analyzing, running, and debugging a Java project from directly inside UNA). Support for more languages, such as Scala and Groovy, and improved support for existing languages. A more comprehensive plug-in framework. Eventually, even refactoring for common languages.

Of course, our ability to add these features depends on having a steady base of users, who work with us to make UNA the best it can be—both for collaborative and personal editions. I hope the developers reading this article will give Personal Edition a try and let us know what they think.

 

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.