The Early Days
Years ago, in 2008 we introduced an interactive C# shell, at the time a challenge was to adjust the syntax to be suitable for interactive use, to provide a usable decent command line editing API for .NET and to turn our compiler as a service into a tool that could provide code completion.
A few months later, we added a UI shell for this on Linux and used Gtk’s text widget to add support for embedding rich content into the responses. It was able to render images inline with the responses:
<img src="http://static1.squarespace.com/static/57efdeff579fb34c24562253/57efe35729852665353fb396/57efe35e29852665353fb713/1475339381370/xpoyxg.png" alt=""/>
This was inspired at the time by the work that
at Red Hat had done on
. You can still watch a
of what it looked like.
Like Owen, I added a plot command:
<img src="http://static1.squarespace.com/static/57efdeff579fb34c24562253/57efe35729852665353fb396/57efe35e29852665353fb738/1475339378207/xlawtm.png" alt=""/>
At the time, Re-interact took some ideas from
and it seems like they are both inspired to some extent by Mathematica’s interactive window.
Re-interact in particular introduced a brilliant idea, which was that users could go back in history, edit the previous expressions and the entire buffer would be re-evaluated. This idea lives on in Apple’s Playgrounds for Swift.
In the meantime, the IPython project grew and they added one of my favorite features: it was now possible to blend text, explanations and code into workbooks. You can see a sample of this here. For years, I have desired an IPython for C#.
The Xamarin Years
In the meantime, at Xamarin, we experimented with the idea of bringing sometehing like Re-interact/Playgrounds to Xamarin Studio and we shippedSketches:
<img src="http://static1.squarespace.com/static/57efdeff579fb34c24562253/57efe35729852665353fb396/57efe35e29852665353fb73a/1475339377230/Overview001.png" alt=""/>
But while these were interesting for trying out ideas and learning C#, they are not very useful for day to day work. We found that what our developers needed was a full C# REPL that was connected to the application they were running on, so they could experiment with their UI live. This is when we introduced Xamarin’s Inspector. We took the existing engine and changed the way you interacted with C#.
The inspector was originally planned as a debugging aid, one that you could use to attach to a live Android/iOS/WPF process and use to examine:
<img src="http://www.flish.co.uk/wp-content/uploads/2016/05/mac-inspector-repl-small.png" alt=""/>
We wrote several backends to provide some visual representation of the running app:
<img src="http://static1.squarespace.com/static/57efdeff579fb34c24562253/57efe35729852665353fb396/57efe35e29852665353fb73e/1475339379102/mac-3d-view-small.png" alt=""/>
While Sketches used the IDE editing surface and a custom renderer view for results, with the Inspector we took a different route. Our interactive surface was an HTML canvas, and our results are rendered using HTML. This allowed us to do some pretty visualizations for results.
We have only started to explore what is possible in this space, and our last release included various data renderers. In particular, we added support for pretty printing collections and a handful of native Android and iOS results.
Up until now, we had been powered by Mono’s C# compiler and while it has served us well for many years, it pales in comparison with the services that we could get out of Microsoft’s Roslyn. Our code completion and error reporting were limited and the model did not translate too well to F#.
We recently switched the inspector to use Roslyn:
<img src="http://static1.squarespace.com/static/57efdeff579fb34c24562253/57efe35729852665353fb396/57efe35e29852665353fb740/1475339383128/inspector-0.6.0-repl.gif.0-repl.gif?format=original" alt=""/>
With this release, we ended up with an Inspector that can now be used either to debug/analyze a running app (very much like a web inspector), or one that can be used to experiment with APIs in the same spirit as other shells.
In the meantime, Frank Krueger took the iOS support that we introduced for the compiler as a service, and wrote Continuous, a plug-in for Xamarin Studio and Visual Studio that allowed developers to live-code. That is, instead of using this as a separate tool, you can modify your classes and methods live and have your application update as you change the code:
Frank also added support for evaluating values immediately, and showing some values in comments, similar in spirit to his
app for iOS:
The Glorious Future
But now that we have a powerful HTML rendering engine to display our results and we upgraded our compiler engine, we are ready to take our next steps.
One step will be to add more visualizers and rendering capabilties to our results in our Inspector.
The second step is to upgrade Sketches based on this work. We will be changing the Sketches UI to be closer to IPython, that is, the ability of creating workbooks that contain both rich HTML text along with live code.
To give you a taste of what is coming up on our next release, check out this screenshot:
<img src="http://www.flish.co.uk/wp-content/uploads/2016/05/csharp-workbook.png" alt=""/>
Developers will still have a few options of richly interacting with C# and F#:
- With our inspector experiment with APIs like they do with many other interactive shells, and to poke and modify running apps on a wide spectrum of environments.
- With Frank Krueger’s Continuous engine to see your changes live for your C# code.
- With our revamped Sketches/workbook approach to use it for creating training, educational materials.
Xamarin Cross Platform Application Development – Book Review
Andy Flisher is a Software Developer based in the North East of England specialising in cross platform development. Mobile Development experience includes Windows Phone, Android, and iPhone Apps. Desktop Software Development includes bespoke Windows, Linux, and Mac Applications. Web Development Skills include PHP, Perl, Python, Xamarin, C#, ASP (Classic and .NET). Andy also has some Industrial / PLC Programming experience – Andy Flisher on Google+
This is a review of the recently published book “Xamarin Cross Platform Application Development” by Jonathan Peppers.
This book is openly marketed at existing, experienced C# developers so it’s certainly not for beginners, and whilst I don’t fall into this category the nature of projects I work in require mostly ‘linear’ development (Web, PHP, Perl, Python, VB etc over the years) so concepts like MVC, MVVM and in particular IOC (Inversion of Control) are newer and less clear. Thankfully this book has resolved that through it’s excellent practical examples.
One area this book doesn’t touch on hugely is the level of planning required for MVC applications, you can’t just ‘jump in and code’, but that’s potentially a book in itself, but what the book does very well for me, is explain the View, ViewModel, Model and Controller concepts in terms of the classes and data layers required. The book also introduces Interfaces (something I always saw as an unnecessary layer of complexity) which I now ‘get’ in terms of flexibility, and in particular to give the developer options in a cross platform environment.
The icing on the cake is ‘Inversion of Control’, whilst the book doesn’t particularly explain this convention in huge detail, I think it is actually to it’s credit, any more and the reader will be bogged down in unnecessary detail and complexity. It basically gives us the service layer that ‘glues’ the application together, allowing use to create and register our ViewModels as Services and thus make them available to use throughout the app with a single line of code. I’m sure that my description is not hugely more constructive than the words in the book themselves, but the working example of the XamChat application completes it.
Which is my main point, am sure many people work differently, but for me working examples of code are what makes it stick in my mind, it helps it all make sense. Throughout this book you will be building bit buy bit a working chat application, firstly in Xamarin.iOS (but using the all important cross platform and code sharing concepts learnt at the beginning of the book), and then re-implementing the same application logic in Xamarin.Android. The nice touch, which some may see as lazy, was that with the Android example you are taken to a certain point and then left to finish off using the examples you already have. A real, and practical exercise which I think will do the reader good. It wouldn’t be a huge leap further to recreate in Windows Phone, for the ultimate practical extension.
The Xamchat application is then extended through the Windows Azure platform to use their backend for data storage (a good example of how the same Interface can be re-used to store on different platforms), and to implement cross platform push notifications.
Lastly there are chapters on using Xamarin Components (including Xamarin.Mobile for Contacts, Camera and Location functionality), and actual App Store submission and their different processes, processes that even the most experienced developer can struggle with (Apple Certificates and Profile expiry anyone!).
In summary, this is an excellent book for any would be cross platform mobile application developer, yes you need a good understanding of C#, MVC and similar concepts, and the individual mobile platforms and general development processes themselves, and those things don’t come over night, but this book binds it all together with real world examples, working code (a novelty for some books) and actual code and methods you can take away and use in the real world.
Buy it, read it, and take as much as you can from it – “Xamarin Cross Platform Application Development” by Jonathan Peppers