Apress’ open source series of books recently unveiled Mark Mamone’s “Practical Mono“, a book targetting new .NET developers. We take a quick look at the book below.The book is written for readers who have no previous experience with .NET, and in some cases, it will even be suitable for readers with not extensive programming knowledge. It starts off explaining what .NET is, the history of Mono and how it fits in all this. It also explains how to install Mono from scratch, but this guide is limited only to RPM-based distros and Windows.
The book goes on to introduce the reader to Monodevelop, although this guide is already a bit old now as the application has changed significantly since that book was written (in the Mono 1.1.4 days). The chapter will also explain how to use the C# compiler, although almost has zero depth regarding debugging (half a page about it).
The book continues with the introduction to C# language starting from the most basic information (e.g. variables) continuing all the way to events, delegates and namespaces. Throughout this part of the book there is quite some source code listed along with some adequate explanation next to it.
On chapter 5 things get really serious with the introduction to JIT, GAC, assemblies and modules. Introduction to Windows.Forms, GTK# and Glade follows. An RSS application is used as the practical example on how to create a graphical C# application using both toolkits. Unfortunately, these two huge subjects are not discussed in enough depth. After reading the book the reader won’t be able to create real-world graphical applications without reading additional books or MonoDoc, or delving directly into other people’s source code for ideas and information. The graphical application creation topic should have seen more love by the author.
The author quickly moves to other territories like ADO.NET and MySQL, XML and ASP.NET, which I personally don’t have enough interest for, but these chapters were well-documented and presented. Back to the real deal, the author continues his journey into more advanced topics such as Remoting, the Mono Profiler, performance tips, networking, Reflection, multi-threading programming, and a quick look up on .NET 2.0.
Regarding the book’s writing is easy to follow, although a bit too monotonic at times. Reads more than a school book rather than a book that you will also have some fun with while learning. Overall, this is a good book for first-timers on .NET, but probably not as good on brand new programmers who would find themselves a bit lost after trying to program a real world application on their own. Most of the information mentioned on the book can be easily found on MonoDoc or elsewhere, but it’s nice to have a hard cover book with all the knowledge put together in perfect order.
Rating: 8/10
Hi,
well the problem with these books is: We don’t need yet another book describing C# and .NET.
What we need is a book describing gtk#, glade#, gnome#, gconf#, dbus#, gecko# and so on.
There is no good tutorial about dbus#. And I wanna have more documentation about these Unix/Linux-specific technologies. I would also buy a book, if it would describe these technologies.
But currently Mono does not support .NET 2.0 completely and the APIs of dbus are still changing very often. So this is not the time for books about mono only, but later hopefully.
I suppose the book will primarily use .NET 1.0, because of the missing features of .NET 2.0 in mono. But .NET 2.0 is, what is interesting.
For everything else I can buy any other .NET 2.0 book.
But another question: In Java development we have a lot of standards and long release cycles. Java 1.4 has been the newest version for a long time. And we have standards j2ee, that don’t change very often.
My fear about mono is, that Microsoft will change the technology very often. .NET 2.0 has been released a few month ago, Microsoft is already working on .NET 3.0. Don’t know, when it will be released, but Mono will have .NET 2.0 in the end of 2006 completely implemented. Maybe a few month, or 1 year later .NET 3.0 (C# 3.0) will be released and Mono can’t follow this speed.
Or is this wrong? Well as developer I don’t wanna learn every 2 years everything completely new. Mono really looks nice and I like it. But I don’t wanna learn it now and learn it in 4 years completely again.
I have learned Java 3 years ago and my skills are still useful and my programs in Java 1.4 are still runnable in Java 1.5. I hope this will be similar with .NET too. The step .NET 1.x to 2.0 caused a lot of broken apps.
Greetings
Mike
My fear about mono is, that Microsoft will change the technology very often. .NET 2.0 has been released a few month ago, Microsoft is already working on .NET 3.0.
That is something I dislike about the .NET, how many years did we have 2.0 in beta? I didn’t wanted to start programing with a beta but knowing that the beta existed I didn’t wanted to start with 1.1 eather, so, I saw the .NET 3.0 videos even before 2.0 were released, and now I have the same problem, why Im gonna start with 2.0 when 3.0 is coming and I’ll have to move my code? I don’t like this early propaganda.
That is something is moving me away from .NET, but meanwhile im starting to use MONO.
Hi,
well but with Mono you will have the same problem. The development is a little bit slower than the .NET implementation of Microsoft, but sooner or later you will have to switch your program to the new version.
But maybe Microsoft will not break the compatibility between the versions 2.x and 3.x. At the times of .NET 1.x the platform wasn’t really widespread. With .NET 2.0 this changed. Now Microsoft also has to take care about the compatibility, if they wanna have the people using .NET.
Greetings
Mike
Hi,
well, the problem is, that Microsoft has the reputation, that they change technologies very fast and very often. But maybe you all are right, and this will change with .NET.
On the other hand: We don’t know, how the .NET development will continue in the future. We don’t know, if there will be any changes, that make .NET more useful for windows than for linux, or if Microsoft will stop the standardization of .NET and go their own way. So novell is really brave to start and support such a development.
If Novell has any agreements with Microsoft about this, they should tell it to the public. So a lot of doubt could be taken away.
And maybe then hopefully a lot of developers will take a look at mono (not .NET only), because in my opinion it currently is one of the best ways to develop software for the linux desktop.
But first we need more stable APIs for things like dbus and for gnome (waiting for the results of the ridley project), so that it is also interesting for bigger companies to work for the linux desktop, based on mono.
And if more developers are interested in developing applications for linux with mono, we will maybe have more books about the details I wrote before
Mike
Well, this is a wider problem.
.NET 2.0 has been in BETA for about 10 months. This is NOT much for such a big technology and software. However, is always a risk to develop against a BETA rather than finished software. That’s not a .NET thing: that’s a common problem. So if you decide to develop against a BETA 2.0 instead of final 1.1 you know you’re taking risks and you will probably need to change (hopefully!) small parts of your code when software gets finalized and released.
As a sidenote, the open-source model made it worst. Yes, having sources always available and people developing against snapshots (not even BETAs!) helps developers to find bugs and to customize software to user requests, however that also make a lot of “pollution” which is always bad.
If you look carefully, you will notice ecosystem is full of programs written against partial snapshots, customized versions of software downloaded from other websites (which hold “private” snapshots), buggy versions, BETAs, ALPHAs and so on. It’s a mess!
There’s a lot of people complaining that their code developed against an early early early ALPHA version of some APIs is not working in BETAs anymore. Or people complain that “they are forced to change code again after I did for switch from ALPHA -> BETA…” (!!).
Microsoft didn’t act like that a few years ago and they started spreading almost-complete BETAs only. Now MS has been forced to please developers who are getting accustomed to have code released faster by introducing CTPs, pre-BETA, early-BETA, RC1, RC2, RC-almost-finished and so on. That’s not bad as a whole but people should remember that developing against such versions IS a risk.
FYI, I’m developing against WWF and WCF BETAs too but didn’t do that until MS allowed GO-LIVE licenses for such products.
Hopefully Mono can keep up with developers releasing products based on new versions of .Net.
Just because Microsoft releases .Net 3 today doesn’t mean anyone will have apps needing it tomorrow! But some things, like linq, may get picked up pretty quick. Also, small changes to API’s have a nasty way of sneaking into your code if you’re not watching for it.
Well, you do not have to upgrade because the various frameworks are backwards compatible. That means that all the work that you do today will continue to work tomorrow.
This also means that you can adopt new technologies when you are ready, not when someone tells you that you must upgrade.
The .NET 3.0 stuff is looking interesting, but its intended for early adopters, those which are interesting in providing feedback. you are not forced to use the new features in C#.
So yes, .NET 2 was on beta for two years, which I think is a good idea as many people could provide feedback on the process: what was broken, what could use tuning, which kinds of features were missing. It was a pretty good beta in my opinion.
miguel
I got a question for you Mister the Icaza:
¿Why F-Spot haven’t been ported to others platforms such Windows?, In theory that would not be that hard and Windows users would love an application like F-spot.
Edited 2006-02-10 14:18
I am not mister de Icaza but or Larry Ewing (creator of F-spot), but I will take a stab at this. F-Spot and other great Gnome# applications that are making it big in Linux now days rely a lot on underlying technologies that are platform specific to GNOME and even lower level pieces that only exist in *NIX. We have just began to make parts of Gnome# available on Win32.
Gtk# the UI library framework written in C# that makes writing GTK GUI applications with ease, makes extensive use of a feature of .NET/Mono called Platform Invocation (PInvoke). This means that although when you are writing your applications you are doing it using C# semantics, at runtime there are plenty of calls to unmanaged function calls that may not exist yet on Windows.
In time we will have full parity or very close to it (97% is good enough?) with Windows, Mac OS X and others, but until then the folks taking full advantage of mono/Gtk#/Gnome# are taking advantage of Linux. Should you?
No one forces you (I assume no one anyhow!) to stay at the bleeding edge, it’s your choice. People will be using C# 2.0 for many years to come, the stuff going into C# 3 is only of limited interest to me (db stuff) so I am quite happy to stay with the current standards for a long time to come.
I’m a recent convert to ASP.NET. I has the same misgivings as the next guy (esp after using ASP on IIS 5.0), but ASP.NET is extremely easy to use. It sure beats PHP for one good reason – I have a support library I wrote in C# that is used by my ASP.NET code, but will also be used in the big jump to a desktop version of my APP (converted from another RAD IDE.) Code once, use again.
If, indeed, ASP.NET is cross platform with Mono (didn’t realise – will look into this), stuff becomes very interesting indeed.
I wouldn’t waste my time learning PHP now, as I can certainly do everything I need in ASP.NET.