Novell Bringing .Net Developers To Apple iPad
315
GMGruman writes "Paul Krill reports that Apple's new iPad could be easier to write apps for, thanks to Novell's MonoTouch development platform, which helps .Net developers create code for the iPad and fully comply with Apple's licensing requirements — without having to use Apple's preferred Objective-C. This news falls on the footsteps of news that Citrix will release an iPad app that lets users run Windows sessions on the iPad. These two developments bolster an argument that the iPad could eventually displace the netbook."
Re:What, no itsatrap tag? (Score:3, Informative)
News Flash - You still need a Mac for installing [monotouch.net] the iPhone SDK and Mono.
You still pay the Apple hardware tax.
Re:What, no itsatrap tag? (Score:3, Informative)
Re:as someone who programmed for both (Score:3, Informative)
Re:Certainly won't displace it in... (Score:4, Informative)
What the hell is it with you flash boys?
Flash would open up a -lot- of content. Things like Hulu, Homestar Runner and many, many Flash games. How many times have you run into sites that are Flash only? There are still a lot of them out there, or sites with HTML, but Flash navigation.
But really why the hell should most people care about flash? So I can't play Bloons Tower Defender 4, or some other stupid game. Give me a real reason to need flash. My guess is whatever your reason, there's already an app for that.
Hulu.
Re:Nothing new here (Score:1, Informative)
Jesus christ stop with the Apple spam.
Why? This is technology-related news. It's relevant.
Is it really going to painfully hurt you to skip over the articles you don't want to read?
I think if some other company that was more "fashionable" around here than Apple had made exactly the same product instead of Apple, there wouldn't be so much crying. To the editors: These kinds of articles are relevant. Please continue posting them.
Re:Easier? (Score:4, Informative)
You really have no clue what you're talking about, do you?
Objective-C is solid, only on its second release (2.0). It has a learning curve for most non-Apple devs. Based on Smalltalk, messages (methods) are bound at runtime. Garbage collection and properties were added in the latest version.
Java is very stable, but given the number of releases I would say less solid (it's on its seventh major release, with a beta for it's eighth). Based loosely on C++, but with garbage collection (no pointers), it is really the only system that produces true cross-platform binaries.
C# is on its third version (3), although the runtime is on its fifth (3.5). Most people agree that as a language, it is superior to Java due to support for events, functional/lambda-style programming, LINQ, generics (which are generally considered better than Java's), etc. C# is standardized, but open source/cross platform implementations (Mono) are behind those from Microsoft. Silverlight, however, is available cross-platform via Moonlight. The next version is in the works (C#/.NET 4.0).
I really don't get where you were saying "if you crash your data is gone". That doesn't even make sense, in the context of a computer programming language.
Re:Easier? (Score:2, Informative)
Given that nearly every Japanese sentence contains both hiragana and kanji, that analogy makes no sense.
Re:Pffff (Score:3, Informative)
Perhaps, but as a woman I can definitely tell you that all my women friends have agreed it's an unfortunate name because the first thing it makes us think of is feminine hygiene products.
What on earth are you going on about? It's not offensive, just awkward. It lacks cachet, which is a bit surprising. Even iSlate would've been so much better -- though really, haven't we all had enough of the "i" thing? It's so '90s...
Re:as someone who programmed for both (Score:4, Informative)
Garbage collection doesn't save you from leaks. A developer still has to be conscious of memory usage even in systems with GC.
At the same time, Xcode offers static code analysis that tells you when you are leaking memory at compile time. There are a lot of language innovations in Objective-C that is noteworthy. As the iPhone's hardware capabilities catches up (that A4 chip sure is interesting), I'd expect to see GC and the introduction of blocks into the iPhone SDK.
Re:Raskin's Dream incarnate (Score:2, Informative)
Re:Easier? (Score:4, Informative)
ObjC as used on the Mac combines the best of both worlds -- you get pointers for low level control, *and* a nice OO framework/API and niceties like garbage collection.
It should be noted that this is equally true for C# - it also has raw pointers [microsoft.com] and related stuff [microsoft.com] available for when you need it, but otherwise it's fully OO, runs under VM with GC, and so on.
Out of my head, I can think of a few advantages either one has over the other.
C# advantages: ...]", but much more extensive - covering sorting, grouping, joins etc.
- namespaces
- generics, so all collections can be statically typed
- first-class functions and lambdas (closures) with argument type inference
- LINQ query comprehensions (a la Python's "[x for x in
- portable code generation with JIT(System.Reflection.Emit & DynamicMethod)
- mark-compact generational GC (ObjC one is a conservative mark & sweep, which means that it's both slower and suffers more from heap fragmentation)
ObjC advantages: .NET JIT, much less Mono JIT
- truly dynamic dispatch, objects can intercept unknown messages sent to them, redirect them etc
- duck typing (C# is going to have it [microsoft.com] in 4.0, though, which is right around the corner)
- can avoid GC altogether even when using all OO-related language facilities, which can have some performance benefits
- can use C/C++ libraries directly, no wrapping or FFI declarations needed
- gcc generally produces better optimized code than
In general, I'd say that C# is a little bit more high-level, but overall the preference for one or another depends on whether you like static or dynamic typing more. ObjC provides more features to go with the latter, but can be type-unsafe at times (e.g. due to non-generic collections).
Re:Garbage collection is over rated (Score:3, Informative)
Eventually came to C++ and saw everyone using new and delete left right and center and I naturally assumed it would have trivial cost. Imagine my surprise when I actually ran the comparison benchmarks. With modern math coprocessors, a sqrt() is just three times mults, sin() is about 14, hyperbolic sine, logarithms are all about the same, inverse trig functions were around 25-30 times the cost of a mult. You know what? A simple push_back() or push_front() to an std::list is around 180 to 200 times as expensive as a mult. Throw in automatic garbage collection on top of this, you are looking at some serious performance degradation.
By the way, this is actually a very wrong way to go around this. Memory allocation in C and C++ (and other languages with memory allocation) is expensive precisely because they don't have compacting GCs - it means that allocation algorithm is that much more complex (and time-consuming), as it has to search for a fitting free block, and update the corresponding memory structures. And, as you keep the program running, and the heap gets fragmented more and more, allocation performance gets worse.
In comparison, a compacting generational GC, as used in Java or .NET, periodically defragments the heap so that unallocated memory is always on top. The result is that a single allocation from a GC heap is quite often literally a single pointer (to lower boundary of unallocated space) increment instruction.
Furthermore, depending on allocation patterns, deallocation with GC can be faster as well - e.g. if you call "new" in a loop in Java, all objects it'll allocate will be in a single contiguous block - and GC knows about that, and will be able to deallocate all objects in that block together (in a perfect case, with a single pointer decrement), if their lifetimes all end at the same time.
Re:Easier? (Score:3, Informative)
Objective-C is solid, only on its second release (2.0)
Categorically not true. What Apple calls Objective-C 1 is actually Objective-C 4, but they reset the versioning for the Apple version with the release of OS X 10.0. There was no version increment when they added @try/@catch/@finally/@synchronized to the language, but if there had been then what Apple calls Objective-C 2 would really have been Objective-C 6.