Which programming language should I try?

[Renegade334]

Got a small question here (I know this is a software/hardware subforum but it felt like the best place to ask this, and I do have a follow-up request for freeware).

I started studying programming a couple months ago to kill some free time and so far I've only touched Pascal (buddy of mine advised me not to try OOP at first, as he saw many people quickly getting confused by OOP's subordinated concepts such as classes, heritage, encapsulation, etc) and am about to have a look at its OOP counterpart, Delphi. I'm still in the procedural language stage but I wouldn't say no to learning some OOP in advance.

However, I've been wondering, among the new object-oriented programming languages, which one would be the most interesting or useful, from a statistical, technical or practical standpoint:

1. Java
2. C
3. C++
4. C#
5. Visual Basic .NET

So, which one? I know Java lacks pointers and the like and that C++, while being an overextension of C (C++ being essentially 'C with classes'), suffers from backwards incompatibility with its parent language...and C# is rather new, since it's a Microsoft creation. I know some of you might say 'it depends on what you want to do with it', but I'd still like an idea of what seems to be, right now, the next best thing since sliced bread in terms of usefulness and the whole nine yards behind.

Also, any free compiler to suggest here? I already know about the Eclipse and Bloodshed compilers but some of them have slight shortcomings (the last Bloodshed Dev-C++ compiler dates back to 2005 and it's still a beta with an annoying bug during the installation process - can't relocate the destination folder to within the C:\Program Files directory no matter how many times I try...and the Eclipse Europa Fall-2 doesn't even come with the <iostream> library) and I'd like some feedback.

Thanks in advance.

[SeijiSensei]

First, if you're really committed to this, I'd leave the Windows world behind for a while and build yourself a Linux box. The distribution doesn't matter, since all them will include what you need: a full-range of languages and compilers and excellent development tools like Eclipse. All of these are, of course, "free" as in both "speech" and "beer," and most are licensed under the GPL.

I'm not competent to answer the language question, but perhaps rather than starting with a low-level language like C, you might also consider a language like Python?

[Claies]

For tl;dr people: Java teaches you high-level stuff like OOP perfectly fine. However, since Java is very forgiving, it also tends to breed bad programmers. C is very literal and teaches you how to do it safe.

===

Long answer:


If you're absolutely clueless about basic programming semantics (If you don't know what a For-loop is, read this), I'd spend a little bit of time with Python before moving into C or Java. Python is very easy to learn, and I'd put it in between C and Java as both somewhat forgiving and minimalist. You can quickly learn the easy stuff like If-Then-Else statements and For-loops. Python also comes with an interpreter that works sort of like a graphing calculator, and you can feed it commands to see what it would spit out immediately.

Java is built entirely around OOP, so it's a good learning tool for that purpose. It's also comparatively very forgiving with errors, so it's the way to learn high-level stuff. You also get to learn how to read documentation, because nobody really knows Java - it just depends on how many classes and structures you know how to use, and you have to read up documentation for new ones to figure out how to use them.

Please be aware that since Java is very forgiving, many people develop bad programming styles and etiquette without knowing it (and that's why if you're into Computer Science, you'll soon believe that Java sucks). For that, I recommend C.

If you try C, don't go too far with it, especially when it comes to OOP and manipulating memory. C is a minimalist language and doesn't support OOP that well. The way you have "classes" is you make "structs", write a little library of functions for it, and pretend it's a class. C, however, teaches you how to program right. C is highly literal and will smite you without reprimand for doing memory wrong. For example, if you run over an array (a list of variables), Java will stop and tell you what's wrong and where. All C would tell you is "segmentation fault", and you'll have to go hunting. However, it also teaches you some very good debugging and safe programming techniques that more forgiving languages like Java won't.

Both C and Python are command-line-based, so be prepared to have the Windows Command Prompt open a lot. For C, I recommend using the gcc compiler. It's simple and straightforward. Python's official interpreter/compiler package is sufficient.

[Doughnuts]

Since you're already familiar with proecdural programming, I don't think you'll be uncomforable learning C++. You can use purely precedural code mixed in with OOP, which might benefit with your learning. Object Pascal is decent in this sense too, but 'Delphi' is more than just a language, it's a product, which includes the IDE, compiler, libraries, components etc for Object Pascal. I don't think it's a good idea to get accustomed to using product-specific libraries and such like you may end up doing with Delphi.

That's where C and C++ shine. There's a huge choice of libraries to use for whatever you want to do, most of the better ones are GPL'd, and ported on Windows. I wouldn't say it's necessary to start using linux like Seiji suggested, because all those resources are avaliable on Windows. What's important is using developing tools and libraries that are portable, so you're not hindered if you do want to change platform.

C++ is much more than 'C with classes' though. It's certainly not easy to get to grips with everything, it's a big language that will take you years to completely familiarise yourself with. When you do so though, moving ahead to other languages is much less work, than say, someone moving from Java/C#. They would need to learn much more about how their hardware works, how memory is allocated and such that they would have previously taken for granted. That's why, as Claies shared, they breed bad programmers; people who don't fully understand the significance what they are coding.

The choice of language is yours though, or do you want even more detail on the differences between them? In any case I'd just say, stay clear of VB.net, simply because it has finite resources for learning compared with the others.

Compiler choice (for C): gcc/g++ of course. mingw is a windows port of the gnu compilers, they tend to produce chunky binaries though. Compiler choice isn't a major concern because if you stick to standards it should compile on anything. IDE is a matter of personal preference too. Most of them will allow you choice of compiler, allow makefile exporting etc too (avoid any that don't. Also, avoid DevC++ because it's no longer under development). I use Code::Blocks, which is completely portable, but has a few bugs of it's own. (If you decide to try it, get a recent/nightly build and not the latest stable).

I can't actually think of a non-free compiler for Java. For C#, look into the mono project.

[Proto]

C++ is much more than 'C with classes' though. It's certainly not easy to get to grips with everything, it's a big language that will take you years to completely familiarise yourself with. When you do so though, moving ahead to other languages is much less work, than say, someone moving from Java/C#. They would need to learn much more about how their hardware works, how memory is allocated and such that they would have previously taken for granted. That's why, as Claies shared, they breed bad programmers; people who don't fully understand the significance what they are coding.

I'd say that is highly arguable though, and greatly dependant on each people necessities. People who will focus their efforts on their IT industries do not really need to learn about the finer working of the Operating systems, and as such languages like C#, Java or other high leveled languages will suit their needs. You don't really need to even know how the Java Machine does its memory allocation if what you are going to program is a decision support system.

Although of course, for people who will dedicate their efforts to other things like emulators, drivers, or anything that is a little more dependant on performance optimization I'd say that C++ is the best option among the OOP languages though, as you have mentioned, since in this case it is pretty necessary to have all the knowledge that you have pointed out.

Again, this all relies on what will you use programming for. If you are only learning programming as a hobby, and your main focus right now is to learn OOP principles rather than proper programming (which is something that you should be carrying from procedural programming anyway) I'd agree that Python is the best option. I've helped as a teaching assistant in some programming courses, and in my experience Python is the fastest language to pick up.

My IDE recommendations has always been Eclipse. Even though what it shines for is for its Java programming capabilties, it is a very flexible IDE whose plugin system allows it to be a programming interface for practically any language. As such, downloading the corresponding plugins will allow you to use it as a C++, Delphi or Python programming tool

[Renegade334]

Thanks for the feedback, I somewhat needed it as a few months ago I had a small chat with a long-time buddy of mine who went to university and was quite dismayed when he started, on his first year, to study OOP without lingering safely long enough on mere procedural language. Learning C++ at once, it seemed, caused a significant raise in dropout or failure rate - to such an extent that last year the said establishment decided to introduce Pascal before even considering OOP. Knowing that object-oriented programming ain't always a walk in the park (I have acquaintances who are relatively familiar with it and say they have no problem but others tend to disagree), I wanted to have an idea of what to try first, if it could help me not only master the subject at hand and slowly work my way up (or down, depending on how you picture it) to low-level languages.

I'll have a look at Python - and, yeah, indeed, Eclipse seems nice. I have the Java compiler (although it's not one of the recent builds as I need to add a 'patch' to enable keyboard input - a small nuisance that's been fixed in later versions from what I've been told). And, indeed, Dev-C++ is a goner for me...it hasn't been updated since 1995, so I believe the folks at Bloodshed have either dropped it or gone dormant. Only issue I have and I might look elsewhere for that is that the Europa Fall-2 compiler for C++ doesn't have the <iostream> file, which is used in the tutorial book I bought a few weeks ago. But I'll see whether I can circumvent this.

Oh, and, by the way, is Borland any good? I know they make a lot of compilers (Delphi, C++) but I have yet to try any of them.

[anime_layer]

I fail to see how learning any high-level language is making you a bad programmer.
Sure, in high-level languages like Java and Python you don't have to worry about memory allocation but that's the whole point of it. And not knowing the low-level stuff isn't a disadvantage - in high level languages. Sure, if you know Python and want to learn C++ then you have to learn to do a lot of stuff that was given before but bad practices for C++ are not necessarily bad practices for Python.

I say, most important is why you want to program and the language depends on the answer to that question.

If you want to learn programming because computers fascinate you and you want to learn how they work, then a low level language is better. There are lots of concept you only need to know when programming a low level language and those concepts also teach you how a computer actually works.

On the other hand, if you want to create an application and that application doesn't heavily rely on performance (95% of all cases), you're better off with a high level language. You simply don't have to bother with a lot of stuff you would have to when programming a low level language. High level languages make away with lot of stuff that's keeping you back and you can focus on creating an application.

I also suggest to consider web programming with either a server-side language like Ruby, Python or PHP or with a client-side language like Flash. You are more limited in those environments regarding what you can do but you also have a much higher reach. Having to download and install an application is an obstruction to a lot of users. Having your application run through a browser will get a lot more people to give it at try.

[Claies]

Originally Posted by anime_layer

I fail to see how learning any high-level language is making you a bad programmer.
Sure, in high-level languages like Java and Python you don't have to worry about memory allocation but that's the whole point of it. And not knowing the low-level stuff isn't a disadvantage - in high level languages. Sure, if you know Python and want to learn C++ then you have to learn to do a lot of stuff that was given before but bad practices for C++ are not necessarily bad practices for Python.

I say, most important is why you want to program and the language depends on the answer to that question.

If you want to learn programming because computers fascinate you and you want to learn how they work, then a low level language is better. There are lots of concept you only need to know when programming a low level language and those concepts also teach you how a computer actually works.

On the other hand, if you want to create an application and that application doesn't heavily rely on performance (95% of all cases), you're better off with a high level language. You simply don't have to bother with a lot of stuff you would have to when programming a low level language. High level languages make away with lot of stuff that's keeping you back and you can focus on creating an application.

My problem is that while high-level languages cover memory and other trivial mistakes for the programmer, you'll never learn how significant the problem is without that protection. I know quite a handful of programmers that don't appreciate the value of defensive programming (sanity checks, buffer protection, stress testing, etc.) until they fully understand how catastrophic it can be when they don't account for all possibilities and how you absolutely cannot count on users to not see exploitable problems.

In my C programming class (yes, we did C), my professor made a point to demonstrate to us at every lesson how things can go wrong and how we should prepare for it. There are commands that specify exactly how much input it takes, rather than eat everything it's given, and there are ways to restrict the range of events code has to handle. He also had a knack of being graphic about it: he'd write code that disobeys that defensive principle and we'll all watch it explode. Other professors who taught the same course paid no attention to this, and our class came out on top of a lowest-common-denominator final exam.

I mean, you really don't need to learn every nook and cranny of the system, but sometimes a little bit of that just to teach people how bad things can get is better safe than sorry. I've seen truly terrible coding practices before and I can't bear how some people ignore protection against misuse over raw performance, simply because they've never been exposed to it.

[Proto]

And again, it heavily depends on what you want to do. If your niche will be extremely optimized programming, to the point that every memory leak, every unused variable, and absolutely optimal and exact memory allocation matters, then you don't learn OOP, or C, or anything like that. You learn assembly and you are programming drivers or programming for microprocessors.

If you are programming an Intelligent Tutorial System targetted towards interactive education, then you obviously you want your program to be responsive within a reasonable frame of time, and obviously you will apply some good and general programming practices. You will take account of the most frequent exceptions and properly catch them, ad infinitum. But you won't really care about how the Pedagogical module interacts with the knowledge repository down to the last bit.

Of course, there are some good programming practices that apply for any language (Modularizing, using design patterns, programming towards intefaces, you name it), and it is always useful to teach students all the work a high level language does for you, so that you can always have it into account whenever they migrate, however those principles and practices aren't in contradiction with the aspects high level languages try to cover from the programmer.

[Doughnuts]

Originally Posted by anime_layer

I fail to see how learning any high-level language is making you a bad programmer.

I didn't and wouldn't say that. In many cases I'd say completely the opposite. It's more to do with the individual and the source of their learning rather than the language itself.
What anyone should know though, is the advantages imposed by their HLL language, why the language has the features it does and how they improve on older methods. Imagine an interviewer asked you that, can you come up with more than a few words for what you know is different? Someone self-taught wont go through the same level of theory as a student, but a self-taught low-level programmer can see the advantages straight off, it's concepts they are already familiar with. That's all I meant by my point about it being easier to migrate and such.

On the other hand, if someone is using a low-level language for the wrong reasons, I'd point my finger at them as the bad programmer. HLLs definitely have the upper hand for the most of modern coding, as long as the programmer understands what they're doing. However, there's plenty of times where they don't, and the result's can be an ugly mess, over-engineered code and real performance killers. thedailywtf will give you some insight into that, I have a few elegant tales of my own too. Ultimately, it's not neccesary to learn everything down to assembly; but there are certainly advantages in doing so.

[wnmnkh]

Matlab is easy to learn, too. I think it is good for starters.

[Furuno]

Well, maybe you want to try ruby instead? It's a very interesting programming language IMO altough i'm also still in the beginning of learning it.

Anyway, giving that choice i'll stick with Java. Java seems fit me well to create programs from business application to game (i've built a visual novel engine with Java). Altough i think it's rather performance demanding than C...

[Proto]

Matlab is easy to learn, too. I think it is good for starters.

Matlab isn't as much of a language as it is a metalanguage for scientific computing though It is ideal for those people who don't want to go through the hassles of learning a language when the program itself is not what they want to do, but possibly they want to just have a quick prototype running, or designing a controller, having a quick soft computing simulation system or something of the sort. And while it is useful for anyone in the area to know it I would'nt recommend it as an alternative when learning how to program.

[Vexx]

You can actually "program" in Matlab but its really as messy as the old BASIC in some ways and hell to maintain (e.g. taking responsibility for a program someone else wrote).
Its forte is all those lovely math packages and display functionality.

First you have to decide --- are you doing this for a living or for fun?
If you are doing it for a living, you need to research what industries use what languages and what platforms. Most of the "heavy-lifter" programmers I know have eventually migrated to Java because it doesn't tie them to a platform. But the realtime and systems programmers end up *nixing (RTOS and embedded fit more easily in that land). If you're focused on user apps or businessware .... the Visual Studio packages may be more appropriate though, really, I'd be ware of any attempt by MS to lock you into *their* environment.

You can learn good or bad practices in any language or programming environment. Some are better at discouraging bad practice.

I still think the best starter language for pure computer science purposes is a subset of C++ but Java has the advantage of all those GUI libraries for instant gratification, so its a toss up.

If you're really hobbying this, you might look at the Lego Robotics kits and the RTOS packages that you can load in for Java or C(++).
Its a few hundred dollars but you can get a good starting grasp on control systems and feedback loops if you want to do programming outside of the "car payment accounting system" type of computing world.

[Epyon9283]

Originally Posted by Renegade334

Also, any free compiler to suggest here? I already know about the Eclipse and Bloodshed compilers but some of them have slight shortcomings (the last Bloodshed Dev-C++ compiler dates back to 2005 and it's still a beta with an annoying bug during the installation process - can't relocate the destination folder to within the C:\Program Files directory no matter how many times I try...and the Eclipse Europa Fall-2 doesn't even come with the <iostream> library) and I'd like some feedback.

Thanks in advance.

Free MS stuff:
http://www.microsoft.com/express/vc/
http://www.microsoft.com/express/vcsharp/

For GCC on Windows you can use cygwin:
http://cygwin.com/

Java JDK:
http://java.sun.com/javase/6/

If you use something other than windows you can generally install GCC pretty easily. Most Linux distros come with it. It comes with the OS X developer tools.

I'm not a developer but I have had to set up some simpleish development environments for others.

[KholdStare]

I had this same problem a few years ago, but I also learned that the concept of all programming languages is pretty much the same, kinda like how if you played Mario before, then you will find Donkey Kong pretty similar (or any platform-based game for that matter). I like Java more because I personally found that it is way more useful than the other programming languages. (Again, this is based on my situations, so no need to flame.)

Short Answer: Go with Java, but it doesn't really matter (seriously).

[Caldron]

There is no need to change to linux to program, that's just a stupid thing to do if you don't want to do it.
You can program C/C++ easily with Dev C++ (which has a lot of devpak for everything, even opengl or directx). You can program Java or Python with Eclipse, there is no need to change your OS.
I'd recommend C/C++ for most uses, it's just the best performance language next to assembly in most cases. Also, it has everything you need to program anything, and offers you the possibility to manage memory at will. However, there are some things that might not be easy to understand.
Java is a bit more friendly and also has a very good performance (sometimes it can overtake C/C++, but the cases are not significant).
Python's performance is something really ugly, but it's an incredibly easy programming language to program some utils that you might want to use either despite the time it takes for them to run or because you are not using much data.

[felix]

Originally Posted by Renegade334

1. Java
2. C
3. C++
4. C#
5. Visual Basic .NET

Well, personally I don't really follow you're way of thinking although I understand your ambition. Please try to use and appreciate a high level language before going knee deep into a lower level one. Why? Because writing readable code is fun. Also higher level languages generally will present the newbie with proper programing concepts sooner rather then later...

As a general purpose editor I recommend Notepad++. I must say I find it's default styles horrid but it's so easy and intuitive to change it's default style to whatever please you in less then a minute (per language) that it's easily ignored as a disadvantage. (make sure to get it's brilliant hex editor plugin as well )

• Java - Designed to be simple, intuitive, easily readable and easily maintainable java programs are built to work. If you are intent on leaning on of those languages from your list go for this one.

  Top 3 Pros:

  • Easy simple syntax. All be it due to subsequent request for features some obscure parts like sub-sub-sub-inner classes are quite ugly, thankfully one can safely ignore the stupidity.
    
    
  • Everything is derived from the master class Object (almost) There are still a few primitive types.
    
    
  • One program all platforms. Java code is interpreted by the virtual machine, hence any environment (operating system) where you could install a jre (java runtime environment) is capable of running your code. (so pretty much everywhere)

  
  Top 3 Cons

  • Java is slow For a database or server application this isn't true, as in 'it's fast enough' as it were, but your average erratic desktop application can't really make good use of java's garbage collection, or at least it doesn't really show in practice. Be prepare to write slow apps. Also while learning the likely hood of getting any reasonable garbage collection for your little app is almost zero, limiting the memory of you application is sometimes recommended. Learning to profile and optimize your programs should be on any Java newbie's todo-list.
    
    
  • Java is very technical and security conscious Be prepared get headaches when tryng to access some high-level functionality. (resorting to a library generally solves this)
    
    
  • Requires native code for certain functions. Java was concieved to work the same everywhere, in a standardized way as it were, this is a good concept, but this means that for some things you may have to write native code (C++ etc) to get the job done. (lookup: JNI for more info on this) (make sure to write fallback code so as to not limit the portability of the application )

  You'll need to get the JDK to program in java. As for editors Eclipse is an old favorite, while Netbeans is probably the most newbie-friendly ATM (try Netbeans5.5 or go for Netbeans6.1beta as the 6.x are somewhat slow)
  These are both free open source projects. Netbeans is supported by Sun, Eclipse has some (payed) plugins by IBM.
  See:
  • http://java.sun.com/docs/books/tutorial/
  • http://www.netbeans.org/
  • http://www.eclipse.org/
  
  
• C - The motha' of all modern languages, generally you'll use C for Operating System Kernell programing and the like. I don't recommend wasting your time with anything else. That said building your own kernel is an unrewarding mind/time-sucking activity. You can try to make simple basic one so as to grasp the concepts of a filesystem, networks, etc to the fullest but going further is likely a waste.
  
  If you wish to program your own operating system, migrate to linux and use the countless linux kernells available. You will require a virtual machine to conveniently run your os and linux meets the needs best.
  
  If you're going to C for fast programs you may want to try Haskell, a functional programing language. Supposedly will produce faster programs because of better optimizations due to the nature of the language; Haskell is one of those languages like xsl where you have to write everything recursively.
  
  I recommend starting with the linux flavor of C++ (use cygwin/netbeans on windows) before going into C.
  Assembly is learned in tandem with C, simply decompile your end programs and learn by example of the compiler.
  When learning Networking concepts I suggest installing a Network monitor such as WireShark.
  
  Learning pure assembly is a good idea (it's simple) But using it may be... overkill and frustrating. Note you don't have loops etc, you have to jump in memory and there's are limits to that as well. You have to work with the processors memory and preferably understand processor architecture. Well it's not that hard...
  

  Top 3 Pros

  • It's fast. C code is much faster then java code, partially because Java runs in VM which is written in C. (or was it C++, doesn't really matter)
    
    
  • You have full control over memory. While a Garbage Collector (GC) is useful, it's generally faster if you do it by hand, and plan it a little. Generally C primitive programs will be always faster then java ones.
    
    
  • Fundamental functions are at your fingertips Needless to say they are harder to work with then the java implementation, this don't really represent a obstacle.

  
  
  Top 3 Cons

  • You'll have to learn to use pointers. In java it's pass by reference everywhere and you don't really have to think of it much, but in C you pass by value easily with outh realizing it. Building good habits takes time but is required. However newbies not only are ignorant of what exactly their passing to functions but tend to have a hard time understanding pointers and memory allocation in general.
    
    
  • You have to be aware of the consequences. Java generally will bitch slap you if you don't check something, and doing basic error/exception checking is the same for everything, you just try and catch. Well in C for some things it just ain't that easy, you have to know this and that act in a certain way under certain conditions, and things usually have their own unique way of working.
    
    
  • Leave your code-candy dreams at the door. C code compared to Java, C++ and others isn't particularly friendly, it's healthy but you may find it annoying in comparison. It's certainly not as fun to write.

  Resources:
  • http://www.netbeans.org/community/re...tructions.html
  • http://www.cygwin.com/
  • http://www.wireshark.org/
  
  
• C++ - "C++ is dead." -Microsoft Official
  
  Any half-assed C programmer can learn C++ in 10min.
  You should never learn C++ with ought grasping C.
  
  Go for C++ if you wish to become a game developer.
  (assembler know-how also required)
  
  Nuff said.
  
  
• C Sharp - Basically Microsoft's Java clone. There are some major differences in the behavior but both languages have so much in common it's not that hard to migrate.
  
  As for which is better, java or c#, it's really a matter of preference. In programing what they can do doesn't really matter, because where there's a will there's a way. You can try to find programs written in either which meet your interest and decide based on that.
  
  Don't get discouraged by linux rants and fanboys, some things microsoft actually does well and easier compared to the standardized way. But like I said, it's a matter of your intrests intersecting with it's proven capabilities.
  
  Free Editors Compilers
  • http://www.microsoft.com/express/product/default.aspx
  
  
• Visual Basic .NET - Probably not a good starting point...

My personal recommendation...

• Ruby & RoR - While not the best language out there it is one of the most fun languages you could learn, also Ruby code is very rewarding, meaning you get some feedback faster then you would by writing in a more mainstream language.

  Top 3 Pros

  • Short, funky and fun smart syntax This little language from Japan has a very short fogiving syntax. You don't have to worry about things like ";" it just presumes you mean them if you have only one instruction on one line. Same for "(" and ")" in function calls. Like java it is a very intuitive language, only in ruby things are also writen to be fun to read not just easily readable. Unlike java it has and encourages short-syntax, you can also overload almost any operator and also some more intresting characters are allowed in method/function names like '?' or '!'. (denoting a true/false respectability a dangerous method) Operator overloading is somewhat extreme, but it's fun to able to do things like take a string str "Ruby is fun!" then do str["fun"] = "great" thus turning str to "Ruby is great!". (many methods are also aliased so you can use what you like, but be careful as some gems redefine the alias )
    
    
  • Everything derives from Object Among redefining the language which some gems (ruby packages) do, it also means things are more flexible and extensible, for example take your average number 3, in your average programing language you can multiply it subtract it etc as well as maybe cast it to some primitive, but in ruby 3 is a object so say you need a the date of 3 days ago you can write 3.days.ago and you get the date. (note that those are 2 methods, but () are optional, and frequently omitted; who likes writing the obvious anyway)
    
    Ruby has Garbage Collection, so no worry about pointers. It's mark and sweep, not as complex as java's hierarchical one as I recall, but it may work better for ruby-like programs.
    
    
  • Java integration There is a java flavor of ruby called jruby which is basically ruby but which can call java classes, it's interesting and worth checking out, but when starting it's good to grasp the native ruby before going into jruby.

  
  
  Top 3 Cons

  • It's not mainstream It's out there it's popular, it's known but perhaps not as used as mainstream languages. Understandably ruby isn't meant to replace them.
    
    
  • Garbage collection could be better. But it's quite good enough as is.
    
    (not really much else in cons )

  When you've learned ruby you may wish to try Ruby on Rails (RoR; a ruby gem). I'm not really suggesting as good for use but it's easy, fast and builds good habits. Make sure to learn from version 2.x onward. I must warn you 98% of tutorials out there are built in 1.2.8 and a certain functionality was mercilessly scraped in the 2.x series thus rendering them somewhat useless. You can install 1.2.8 if you really wish to try out the tutorials.
  
  Presuming you'll want to try it out after installing here's a quick Log demo. (install instructions included; presuming windows command line)
  
  (add the ruby dir to the path in wondows system)
  

  > gem install rails --include-dependencies
  Rails is now installed.
  > cd c:\demo\
  > rails -d mysql LogDemo
  > cd LogDemo
  > explorer config
  > (open database.yml)
  Add your password and save.
  > rake db:create:all
  > ruby script\generate model Post title:string body:text
  > rake db:migrate
  > ruby script\server
  
  # http://localhost:3000/posts/
  Now you have a log with basic post crud. (create/read/update/destroy)
  You can go to app\view\post to edit the way it looks.
  
  To destroy the project.
  > (Ctrl + C) to stop the server.
  > rake db:drop
  > cd ..
  > rmdir LogDemo /S

  Resources:
  • http://www.ruby-lang.org/en/
  • http://www.rubyonrails.org/

Hopefully this helps you somewhat.

[anime_layer]

http://blog.magnetk.com/2008/03/26/h...e-development/

Interesting post detailing the advantages of using a high-level language even for an application like an SFTP drive. They were able to finish in 1/3rd of the time and have more time to invest where it actually matters.

[Jinto]

Originally Posted by anime_layer

http://blog.magnetk.com/2008/03/26/h...e-development/

Interesting post detailing the advantages of using a high-level language even for an application like an SFTP drive. They were able to finish in 1/3rd of the time and have more time to invest where it actually matters.

They just never learned to manage code. One should take this for a bad example actually.

Lets presume good user code management, then it is more likely to run into random compiler/library problems using the managed (garbage collectors etc...) code coding languages than the more down to the architecture ones like C.
Of'course managed code is nicer to program and to manage when you do not trigger one of the bugs or limitations that often comes with it. For instance I have wasted lots of time trying to work around "side-effects" caused by using C#.

But what can one expect of a coding environment (C# is much more than just a language) when it is develloped in a short time, and supports/relies heavily on tons of transparent libraries (you cannot look inside them) to make high level functions available. ... Which is the main reason why one is screwed when running into problems that are related to buggy function implementations in libraries or compiler errors (a return address for a function is only then a usefull debug information, if there is corresponding source code available... *but that is in big part a problem with the non-open source MS-stuff only - C#).
Other high level languages i.e., Ruby do not have the non-open source problem but evolve too fast. Functionality is added much faster, then reliability and bugfixing is taken care off. Lets say one uses version 1.x and has the bugs x,y,z and wants them corrected for this version... bad luck, since x is bugfixed in 1.x2 which contains the bugs a,b thanks to the new feature moo. Y is bugfixed in 2.x, which does not support some of the stuff in 1.x anymore. And z was never fixed.
Well if one tries to do reliable code management with such a language as foundation, one will have "fun" for years to come.