Hi All,

I am currently learning VB and C# and have been for the last two and a bit years but I would really like to broaden my programming skills a little bit.

I was just wondering what people would recommend learning?
I have looked into ruby a little bit but haven't really dug my teeth into it, I have also looked into F#.

I can't really decide which way I should go.

+10  A: 

You should learn Ruby.

I learnt ruby after learning C# (this was in the early days just after .net 2 was released), and I am a vastly better C# programmer because of it.

I can't speak for F# as I don't know it, but I would think that ruby will give you a reasonable 'beginning' for F#, as it introduces a fair bit of functional programming.

Orion Edwards
That's a heck of a testimonial for Ruby then! I am off to http://www.ironruby.net/Documentation
Yep. The design patterns and code that you get exposed to from ruby (and particularly rails) open your eyes up to a whole lot of new stuff, which you can then apply in C# using LINQ. You'd learn most of the programming techniques eventually from coding with LINQ for a few years, but you wouldn't get the same perspective (which is IMHO really important)
Orion Edwards

I think it depends on where you want to go, if you want to get into web development, then ASP or PHP, depending on your preferred stack. I'm a *nix guy so I gotta' say c++ or anything more portable like Java, Perl ect.


Well, it depends on what you will do with it. There's no single language that rule on every feature, so it really depends.

If you REALLY want a single language as an answer, I'd say C++. It's tough to learn and to use, but once you know it (and have used it a little), I'll have understood some concepts that will help you learn any other language.

+14  A: 

Learn a functional language, like Lisp, Scheme, Haskell, Erlang. Otherwise, you're not really doing anything other than learning how to write the same code in a different dialect.

Functional programming requires a shift in how you think about solving problems.

Alternatively, spend more time on using the languages you do know. With 2 years experience, you've barely scratched the surface to be honest.

The only "benefit" to choosing F# i can see would be that it's part of the .Net ecosystem. The other languages I mentioned are far more mature and have plenty of existing learning material out there.
Objectively, F# has many other benefits over the previous generation of functional languages. For example, GUI programming is much easier with F# than with any other functional language. There is also a commercial market for F# libraries but not for other functional languages.
Jon Harrop
And after that one could learn some Verilog, which requires yet another shift in how you think. (commenting because I wouldn't _actually_ recommend this unless you really want to learn another new paradigm just for the sake of it)
+6  A: 

Learn more C# and .Net. The framework is gigangic, and there's no way that you know everything about it.

Also, learn about algorithms and other important computer science topics.

edit: While I'm just now starting to learn it myself, F# seems like a good way to learn functional programming, while being useful to you and while allowing you to leverage your existing knowledge of .Net.

+25  A: 

If you're already familiar with VB and C#, and you're confident in your knowledge of patterns and things architectural, I'd like to expand on the advice given by warren_s and advise you check out F#. F# is a useful functional/OO hybrid language that compiles down to MSIL and runs on the CLR.

The first thing though, is make sure you're familiar with patterns. Read GoF's design patterns and then Martin Fowlers Patterns of Enterprise Application Architecture. Implement some of the patterns that new MS technologies have hidden from your sight, such as lazy loading.

Also read up on the various styles of development. As a MS programmer, you're probably most familiar with data drive development, focussing on DataSets and DataBinding to your UI. Now you have a few years experience, investigate Test and Domain driven development. Get familiar with the nuances of the currently popular techniques and why many people are anti-microsoft, and why microsoft are changing to become more like every one else.

Great advice. I'd like to add that after learning patterns, it pays to also learn when to not apply them. :)
yeah :) maybe learing anti-patterns is the way to go.
Well the way to always go is to be skeptical over the application of anything. Never outsource your thinking process to someone else.
+3  A: 

See my previous answer to this same question.

Why not try to specialize your experience instead of simply re-learning the same things with a new syntax.


  • OpenGL or Direct X
  • Network programming in general
  • Learning protocols such as HTTP, FTP, SMTP, …
  • Neural nets / AI
  • More with XML XSLT / XPath / …
  • Image processing / Video processing

If you’d really like to learn a new language I’d recommend to learn a functional programming language such as Erlang, Haskell, ML, F#, Scheme, LISP. You will learn a lot from the different point of view.

Brian R. Bondy

Thanks all,

Everyone one is so fast to answer its great. I think I will have a look into doing some work with F#. Since GIS/Asset Management is my main field of work and its very function based it would properly be handy knowing some form of functional language.

Thanks Rob Gray for the recommended readings, I'll have a look into those.

Thanks all again for you quick responses.

Nathan W
Stackoverflow isn't a forum, so responses like this should be added as edits or comments on your original question.
Stewart Johnson

i would suggest you learn Flash and Actionscript. That should enable you to transition to higher level languages.

+10  A: 

Python. Great language with a very clean syntax. Learning and using it has actually made me a better C# programmer.

For example, Python allowed me to better understand what are lambda functions and when to use them. It probably would have taken me longer to get that concept with just C# alone. C#'s syntax for lambdas, anonymous functions, and especially for delegates served as a distraction to comprehending its intent and how useful it can truly be.

Python has also served as a nice utility scripting language to support my core development efforts in C# from writing build scripts to using it for code generation. The equivalent of those tasks would have taking me longer to code if I just used C#.

If you do want to stick to the .NET world then look into IronPython. Essentially same syntax as Python but interpreted and runs on the .NET CLR.

Ray Vega

How about digging somewhat deeper in the inner workings of a computer, e.g. in order to really understand what memory is all about, how pointers are used, how the CPU processes the data, etc. ? You could indeed follow the C/C++ path, but you'd still be pretty high level. Why not play around with assembly language? You could for instance try and pick IL, the intermediate language generated by the .NET compilers, which is a synthetic assembly language understood by the CLR and which gets translated on the fly to x86 (or whatever) instructions by the JIT. Or maybe, you could try to understand how your code executes, by following step by step in your debugger, at the disassembly level.

For those of you who understand French or German, I'd recommend trying out the free Dauphin Simulator developed by a Swiss company (French page is here http://www.epsitec.ch/dauphin/). The Dauphin simulates a simple 16-bit CPU system where you can manipulate the memory, the registers and very simple I/O peripherals.


Without a doubt I would pick ruby.

Some people will probably suggest that you jump into functional programming (e.g.: LISP) but I expect you'll find that too big of a jump given your heritage with VB and C#.

Ruby will introduce you to a different style of programming (i.e.: closures) that is a movement towards functional programming without making the full jump. Then one day when you try out LISP at least some of the concepts will seem familiar.

Stewart Johnson

I'd certainly agree with what Pierre says (I'd vote him up but I don't have reputation yet).

It's very useful to have the knowledge of the inner workings of a computer and the lower level behind you when you're working in higher level languages. It gives greater scope in what you're doing and means you can write far better code. C/C++, X86, or reading a book about hardware and what's actually going on in the computer like Code by Charles Petzold are all great choices.

Alternatively you could branch into specific algorithms, cryptography, graphics (as someone else suggested). It mostly depends where your interests lie, are you a maths guy, or into finance, maybe you like statistics or psychology. By trying to keep with what you know and enjoy you'll enjoy the programming experience better as well.

I hope this can be of some help and I hope you find the right langauage/subject for you.

+1  A: 

You can also learn something very different i.e. LISP. F# will also be good, as it is a nics OO/FP hybrid thing

Varun Mahajan
+2  A: 

Three languages I recommend to anyone who already has the Fortran/Algol/COBOL descendants worked out:

Forth, which is another procedural language, but one that forces you to understand the machine you're using. This will give you an insight into the nature of computers at a low level without subjecting you to the pain of Assembler.

Lisp, the only true language, the one that God wrote the universe in (don't believe Randall Munroe on the topic). The user community can be a bit painful at times, but it's good to use a language that feels so thoroughly unlimited.

Prolog, not a language so much as a single algorithm (unification) taken to its logical extreme. Understanding the nature of backtracking is the key here.

The essential gift that each of these languages gives you, which the traditional procedural languages don't, is an insight into a different way of looking at algorithms. Forth teaches you to see the bytes and instructions clearly without the haze of high-level abstraction; Lisp teaches you that abstraction is what programming is all about and the details are much less important; and Prolog teaches you that, in effect, any problem can be modelled in more than one way.

I expect you'll never use any of these languages in real paying software development, but the knowledge you gain will repay the time you spend on them.


Go and learn a function language.

I'd recommend Haskell, because there is a very good book how to learn it: http://book.realworldhaskell.org/

Afterwards, since you are familiar with .net, I'd recommend F#. But learn Haskell first.

+1  A: 

If you are looking for a new challenge why not try silverlight

+3  A: 

Since this seems to have turned into a cheering section for functional programming, I want to throw in my two bits. I would not spend a lot of time learning patterns if you are going to be learning a functional programming language. Functional programming reduces the need for many of the patterns simply because the structure of the language already solves many of the problems that patterns were created to handle. I'm a C# developer and it is nice to see that many of these concepts are being implimented into the language. A more detail explaination of some of the issues that are taken care of, plus a great tutorial from an OO perspective is: http://www.defmacro.org/ramblings/fp.html
Slava does a great job of explaining functional programming from an OO (Java) perspective.

Another great functional resource is: http://mitpress.mit.edu/sicp/full-text/book/book.html
It is in Scheme but is really a great (free!) book for building a base for functional programming.

Good luck!


You should focus on learning to make better designs using the skills you already have in vb and C#.

If you don't have experience using databases I would spend some time on that.

To make better design I would look into design patterns. Dofactory have some nice example implementations. Link: http://www.dofactory.com/Patterns/Patterns.aspx

Another place to start is to read a book by Jimmy Nilsson called "Applying Domain-Driven Design and Patterns: With Examples in C# and .NET". This is also referred to as DDD. Link: http://www.amazon.com/exec/obidos/ASIN/0321268202.

+2  A: 

I would recommend learning a lower-level language, like C or C++. You will:

  • Gain an appreciation for certain niceties of high-level languages, like the foreach construct.
  • Learn about the implementation on the underlying platform
  • Be able to write more CPU-intensive or time-constrained programs
  • Be able to speak meaningfully on subjects of optimization. (The answer is, of course, don't until you're sure you have to)
  • Understand the challenges of platform-independence.
+1  A: 

Learn Assembly...when you can open a hexeditor and write your code (or better yet, open someone else's code in a hex editor and understand it) then you've got a pretty good grasp of programming! :)

David Heise
+2  A: 

I recommend learning about any programming language that supports high level multiprocessor programming. .NET is getting this in the System.Parallel library very soon (the CTP is out at the moment).

The number of available cores and CPU's is only going to increase into the future. F# lends itself to this style of programming.


If you want to do more front-end work then I'd suggest getting into markup languages like HTML and XML along with scripting languages like JavaScript or Script# may be a good Web skill set for one idea.

Another way to go would be into databases like MS-SQL or PL/SQL which may complement what you already do with databases in VB or C#.

Scripting languages may also be an idea for something with less form to them like Windows Script Host or other languages used in CMD or BAT files.

JB King

Java, Ruby, Python, Scala and Functional Programming with Rebol as it is the easiest and most powerfull language see for example "Map Reduce Functions in Rebol: towards Massive Parallel Functional Programming" http://reboltutorial.com/blog/map-reduce-functions-in-rebol-towards-massive-parallel-functional-programming-part-i/

Rebol Tutorial

Learn design patterns, test driven development and functional programming (F#).

Forget all the RAD - stuff you were doing. RAD is nothing but a big malpractice that doesn't let you explore all the potential you have.

Develop software using unit tests only, thats the way to go.


Don't go Ruby, Python or something similar.

You don't want to waste your time learning a fringe language that has only a very limited infrastructure.

I'd stay with .NET at any cost.