Discussion on:

Try the SL4A scripting environment for your Android device

I just sent in a submission to Mary... about my struggles getting IronRuby working on WP7. It's theoretically applicable to IronPython as well, and I found a guy offering a Ruby interpreter to run on the phone as well.

J.Ja

I think I understand the main underlying reason for your preference for WP7 over Android, now. Of course, your previously stated complaints about Android are valid -- but so are your previously stated complaints about WP7, so I have never really felt like those complaints were enough to explain the strength of your preference.

The key, I suspect, has more to do with what you use on your workstation, as contrasted with what I use on mine. Because I tend to use Unix-like systems as close to exclusively as is reasonable, and you tend to use MS Windows systems, there is a built-in preference. It's not about the basic interface, though, given that WP7 and Android interfaces are more similar than either is to its workstation-installed genetic sibling. Instead, it's about the fact that we both write a lot of code.

Until I started writing code for Android, I had a vague philosophical preference for it over WP7, but no particular practical preference to speak of. My preference for Android has grown as I have done more coding for mobile devices, though.

That's because Android is essentially more compatible with my preferred development tools. Meanwhile, WP7 is essentially more compatible with the development tools you use every day. As I read your brief mention here of struggles getting IronRuby working, I found myself thinking "Why go through that trouble? In the end, all he's going to have is more .NET development, and there's almost no real benefit in that. I'd much rather just use Vim on my laptop, or even the SL4A native editor on my Android device, than screw around with a .NET reimplementation of Ruby."

Then . . . it hit me! .NET is your de facto preferred development environment, because that's your habitual development environment. It is only natural that you would feel more empowered using IronRuby with .NET; by contrast, it is only natural that I would feel more empowered using JRuby with SL4A's API wrapper, especially since I get to just write what amounts to standard, portable Ruby code with no regard for a .NET ecosystem or anything like it, aside from my code that has to interact with the mobile hardware platform. For you, .NET code feels "portable", but for me it feels like the opposite; for me, run of the mill non-.NET Ruby code feels "portable", but for you it feels like the opposite.

Both the Android and WP7 platforms have their problems for the user -- big, huge, annoying, face-stabby problems. They also present problems for developers. Each presents a very different development culture and environment; each of us has a different sense of what development culture and environment feels like "home". There, I think, is the real difference in preference.

Let me know what you think about it.

Within a week of the RTW of the WP7 toolkit in its final form, I had my first WP7 app ready to go, despite never touching Silverlight before... simple familiarity with Visual Studio and the .NET libraries and the .NET concepts of "how things are done" got me most of the way there. Less than a week after getting my WP7 phone running, I had sideloaded an application which I've had under development (nowhere near ready for the marketplace) for personal use. What WP7 gives *me* is what *Nix gives *you*, which is the ability to rapidly leverage existing knowledge to customize and tweak things to work precisely the way I want. In fact, if you look at a lot of my WP7 development complaints (the technical issues), they revolve around that very issue, places where the SDK doesn't let me do what I want to really tweak things (like volume control).

And you are 100% right about why IronRuby is attractive to me. It's because I have a great history with dynamic languages, and Ruby is really great to me... but at the same time, I have a huge investment in the .NET ecosystem. And my investment is *not* financial, it's time, energy, and learning. I've been using .NET as my primary development platform for 8 years now (has it been that long?). Switching platforms would mean having to relearn:

* A language
* The base libraries
* The key libraries/frameworks for accomplishing common tasks (Web dev, I/O, XML processing, DB access, desktop apps, console apps, etc.)
* The overall workflow model (for example, WinForms uses events to handle user actions... what do other systems do?)
* Surrounding tools (debuggers, profilers, etc.)
* The ecosystem (such as, "what Web sites have accurate information?")

A lot of people seem to think that it's no big deal to learn a language... and it's not, at least not learning the basic syntax. I picked up Ruby's basic syntax fairly quickly, as expected. But for me to take "I know Ruby's basic syntax" and suddenly move to Eclipse + JRuby... well, not only would I be dumping years of learning, but I'd be spending months to daily work to achieve my current levels of proficiency.

One of the things that I've learned is that there's a difference between spending 1 hour a week on something for 40 weeks straight, and 8 hours a day for 1 week on something... you'll learn a LOT more with the latter. Intense, regular work always teaches you more than casual use, even if the total time is the same. For me to be as effective in Eclipse + JRuby as I can be in Visual Studio + IronRuby, even if the former is provably a much better combination (and I have every reason to believe that Eclipse + JRuby is excellent), would take me months if not years.

As you say, .NET is "portable" to me. I will, most likely, be able to get more done in Visual Studio + C# + Mono on a *Nix system than I could in Eclipse + Java on a *Nix system, despite the quirky nature of Mono and that fact that the combination violates so many principles of *Nix application design. Likewise, you'd probably do better with Perl (or Ruby) + Tk to develop a Windows application than you would to learn Visual Studio + C# + WinForms or WPF, even though the latter is much more so the "right way" to write a Windows app. Portability is not merely a function of technical specifications, ability to cross compile, etc., it's also a function of the knowledge base. Even when I was writing Perl/CGI, I deliberately went out of my way to write them in a manner that the base OS was irrelevant... despite writing Perl/CGI for many years, I never learned a thing hands on from the experience about the *Nix development philosophy. For example, while I have a passing familiarity with the fork/join model for parallel processing, it's at the "Wikipedia entry" level, not the hands-on, "could use this in a real project" level. But put me in the .NET environment, and I can write multi-threaded apps in 4 different paradigms without thinking too hard, just because I have a lot of hands on experience with the threading models that .NET likes.

In terms of feeling like "home", yes, that's an astute observation. Every time I've started Eclipse, I felt lost. The only comparable feeling I've ever had like it in my life, was the first time I found myself in Penn Station in NYC trying to get a train back home. I had taken trains many times before, and coming *in* to the station was OK, but walking in that door and trying to go from "I'm in the station" to "I'm on the proper train with the correct ticket" was incredibly difficult, emotionally it was incredibly draining. It isn't that Eclipse is significantly more complex that Visual Studio (if anything, it's the other way around) or that the Ruby/JRuby/Java ecosystem is any more complex that .NET (they seem to be comparable), but that it's so different, I don't know where to start. I can't tell you how many times I tried re-igniting my learning of Java, only to fail an hour later... stymied by the Web site and not being able to figure out what to download! What's the different between J2SE and J2EE? Does JDK5 uses Java 6 or Java 5? What in the world is a "Spring" or a "Struts" or a "JNI" and do I need them too? Likewise, I'm sure that a non-.NET developer would have the same experience... what version of .NET lets me develop Web apps? What's the difference between ASP.NET, ASP.NET MVC, WinForms, WPF, etc.? LINQ-to-SQL vs. ODBC vs. ADO.NET vs. Entity Framework vs. LINQ-to-Entity Framework? When I started looking at Ruby, there were questions like, "what's a YAML and why is it important?" and "what exactly does 'Rails' or 'rake' or 'gems' do?" These are the kinds of things which insanely few tutorials, getting started guides, etc. take the time to explain.

Hmmm. I think I know what to write about for two weeks out now.

J.Ja

> Hmmm. I think I know what to write about for two weeks out now.

Good thing I have other stuff in the queue, or I might beat you to it.

By the way, I have never felt any urge to use JRuby until I basically had the choice to either do so or not write Ruby on Android. I don't really consider the JVM any more a Unix-compatible platform than Mono, and that poor fit between Java and Unix becomes incredibly clear in the way it is such an incredible hassle to install and set up for basic use, sometimes. Unlike Mono, it's not even "free" enough to install legally without bowing and scraping for a corporate benediction. Attempts to integrate it with the primary software management archives of open source OSes result in more of a pain to install than downloading an installer from Oracle and doing so outside of the software management system on Red Hat. Of course, the latter results in a lack of centralization of managing your installed software, which means you're breaking one of the benefits of using an open source OS.

Java is "portable" in that it's about equally annoying and ill-fitting on every platform.

re: portable code (as you mentioned with Perl)

For anything more than a glorified sysadmin shell script, I try to write platform-independent code as well. It's pretty much the case that, as long as your OS has something the language can treat as STDIN and STDOUT, my code should probably run on it. I find that this greatly improves the quality of code when working with a dynamic language, since touching the underlying system too intimately starts making the design of the system show through the syntax of the language too much, damaging the illusion of a consistent development model built into the language. Knowing how the underlying system works is important, of course, but that doesn't mean your code should look like the underlying system when writing code in the Unix tradition.

I'm going to write a brief primer on the basic .NET techs, what they are, what they do, etc. Something where I spend maybe 3 - 5 sentences per item. I'd love to see something similar for the Ruby ecosystem (for example, "YAML", "Rails", "Rubinius", etc.).

That makes sense about not wanting to use JRuby until you wanted to do Android. The JRuby ecosystem is only appealing to me because it allows Ruby to be run in places it normally would not go. The Java libraries and interaction with the OS are not appealing to me. There's some useful stuff in there, don't get me wrong, and I feel like Sun's inability to do anything useful made the open source community around Java much more active than .NET's. But for the most part, the .NET world just watches Java (and Ruby, for that matter) and copies anything truly useful (ASP.NET MVC and NHibernate are two great examples of .NET cherry picking ideas from other systems) while leaving the less useful stuff aside.

It's too true about Java & licensing issues. I tried a Java-based CMS on my FreeBSD machine ages ago... what a nightmare it was. Never mind the fact that I've always thought that Tomcat felt like a helpless kludge (my opinion of Apache dropped a lot due to Tomcat), just getting the JVM itself installed and running was a truly mindbending experience due to the licensing. I was utterly baffled by the decision making process that went into it.

J.Ja

I was thinking you wanted to write an article about different developers' perspectives on different development ecosystems and platforms, based on their experience and skills. I don't think I'll ever write a complete article just about that, at least for TR -- it occurs to me there simply isn't enough concrete material in it to make it appropriate as an article for this venue. I will, however, touch on it briefly in the introduction to an article I'm planning for the open source column right now, though.

I might put together something along the lines of a "basic Ruby techs" explanation, I guess. I'll have to see if there's a set of "default" technologies that makes sense to explain. Considering the open source Unixy culture of the main Ruby community, though, it's difficult to settle on a single example of central categories of technologies to consider "basic" or "default". It would be a lot easier to write an article covering the different Ruby implementations, and another covering the various Web frameworks, and so on. I mean, sure, YARV is the new default Ruby implementation, and Rails is the default Web application framework, but there's no single default marshaling format, no single database access library, and so on. An article covering three "basic" Ruby technologies with three to five sentences each seems pretty scant and dull.

I guess I could spin a "basic Ruby techs I use a lot", and ignore the "defaultness" or popularity of my choices for the most part.

> The JRuby ecosystem is only appealing to me because it allows Ruby to be run in places it normally would not go.

Considering YARV runs just about everywhere, there are few cases where JRuby would be needed, by that standard. Android is the only platform that comes immediately to mind, and if you have a rooted Android device you might even be able to port YARV to it as a native binary. I'm not sure about that, though.

This environment is finally getting truly scriptable. Almost thou persuadest me to go out and buy a smartphone.