Disclaimer: this is an automatic aggregator which pulls feeds and comments from many blogs of contributors that have contributed to the Mono project. The contents of these blog entries do not necessarily reflect Xamarin's position.

June 24

How to be Successful with Mobile DevOps

The rise of smartphones and changing user behavior over the past seven years have forced organizations to start delivering more and more mobile solutions, with apps a big part of this. There are unique challenges when it comes to enterprise mobile app delivery, however. The ecosystem is fragmented, yet users continue to have high expectations. It’s the “age of the customer” as Forrester puts it, and enterprises need to not only live up to their expectations but exceed them in order to stay competitive.

“After an unsatisfactory experience with a mobile business app, 65% of users will abandon the app after two or fewer uses and 8% will abandon immediately.”
–Xamarin Mobile Business User Survey, 2015

Speed, quality, and continuous iteration are critical to the success of mobile apps, no matter if the audience is comprised of customers, internal employees, or business partners. DevOps can provide an efficient way to embrace this complex ecosystem and streamline mobile app delivery for building, testing, and continuously iterating. The concept of DevOps is not new, and companies have been implementing it for a few years now, but how do you take this to the mobile world and address the unique requirements there?

Download our Mobile DevOps Overview whitepaper to learn more about:

  • The unique challenges of enterprise mobile app delivery
  • Why you should consider implementing DevOps in your mobile lifecycle
  • The challenges with applying DevOps to mobile
  • How to implement DevOps in the mobile lifecycle and be successful with it
    • Why starting with people and culture is critical
    • Creating a living, breathing plan that you can constantly update based on market changes and user feedback
    • Being smart and efficient about how you build your apps
    • Taking into account all of the integrations that mobile apps have and planning ahead for easy scalability
    • Treating testing as an enabler of DevOps and not a bottleneck
    • Continuously iterating to keep up the quality of the apps, and keep users engaged


Get the white paper

The post How to be Successful with Mobile DevOps appeared first on Xamarin Blog.

June 23

Overcoming bias to become better leaders

What we learned at the Women in Gaming Workshop San Francisco

As you might know, today marks National Women in Engineering Day, a moment to raise the profile of women in engineering and focus attention on the amazing career opportunities available to girls. At Unity we’re proud to do our small part to help develop women and girls as they pursue their careers: our women in gaming series, focused on skill-building for women in technology, has taken us from Amsterdam to San Francisco for a second session. This week 75 attendees gathered for a fun and informative discussion with UC Berkeley Haas School of Business Professor Dana Carney. An affiliate of the psychology department, Professor Carney studies ordinary, non-verbal behaviors and social situations. And what’s more social than the workplace? With a focus on skill-building and developing women in their careers, Professor Carney discussed how to improve the ability to lead and influence by understanding and leveraging inherent bias.

Unity CEO John Riccitiello with Professor Dana Carney and Unity Chief People Officer Elizabeth Brown IMG_0331 IMG_0350 IMG_2093

While it was a wide-ranging talk, I wanted to share some takeaways that I hope will shed a little light on how you can use natural tendencies to hone your influential leadership skills, especially in group decision-making scenarios. She also reminded the audience several times that we are in fact “all just animals.” :)

Every day we make decisions, from a new hire to a timeline for deployment or the tools on which we’ll build our next invention. We are judged on our conviction and the ability to sway and influence others in order to make decisions collectively. In the process we often demonstrate bias, which a) isn’t always valid and b) is “evidence” that’s tough to double-down on, especially when you are asked to defend your position or convince others to follow.

Professor Carney explained that intuition is simply the brain acting on pattern recognition. By getting to the root of what factors shape and influence these patterns, we can move beyond intuition to rational thought, to foster more productive communication. In turn, you’re better positioned as an influential leader who can tap into individual strengths and draw forth critical information which adds up to — you guessed it — faster, more logical collective decision-making.

To boost your team’s collective strength and productivity (meaning…being a better leader!), keep these things in mind:

  • Acknowledge bias: we all have them, and they can often carry undue influence. Rather than sweep them under the rug, put them on the table and give them a hard look. By acknowledging our potential biases, we limit their power to influence decisions.
  • Diversity has real impact: diverse thinking comes from diverse bodies and experiences. It’s a no-brainer, but different opinions should be considered a strength. Seek conflict, and drive thorough discussion. Your business will be better for it: research shows businesses with more women see greater rates of innovation, rational decision-making, and increased sales and revenue.
  • Beware premature consensus: Don’t feel the need to agree right off the bat. Healthy debate is more beneficial, as long as teammates trust each other. Conflict should be about the information presented, not personal relationships. As a leader, keep the team focused on a goal — getting shared information to drive a decision — we can unlock the minds of everyone present and the true benefits of group think.

Huge thanks to Professor Carney for her time, and everyone who joined us. Our next event will take place in Shanghai, and we’re back in San Francisco in September (register now). Keep an eye on the blog for updates, and we hope to see you soon!

The State Of Performance Reporting II

Performance Reporting aims to be a suite of tools. At the moment, only exception reporting is available as a feature of our Performance Reporting service. This has lead to some confusion as developers often are looking for profiling data. In the future, we see Performance Reporting becoming a suite of tools for things like benchmarking and getting some lightweight profiling data.

How Performance Reporting fits in with Analytics, Cloud Build, and Collaborate

We often get questions about how Performance Reporting works with our other Unity Services. Our vision is clear, and we would like to share it with you now.


Analytics is about helping developers understand their players. Performance Reporting is about improving the health of your game. By bringing these two together, we can see how bugs impact your players.

In the future, you’ll be able to cross reference game session data with exceptions.  With this, we can correlate an increase in exceptions with the end of a session.

Cloud Build

Cloud Build is all about automating your build process so you can focus on your game. Performance Reporting’s most requested feature is Native crashes. One struggle for native crash support is getting the build symbols, so that the native crash reports are readable by humans.

Again, by bringing these two together, we can give you native crashes just by turning both the services on. The future we see here is native crashes with two clicks. Just enable Cloud Build and Performance Reporting.


Collaborate is all about seamlessly working on your project with a team. Part of good collaboration is having a clear overview of bugs that currently exist in your project. Performance Reporting will be able to use Collaborate’s project history to help narrow down where and when a bug was introduced.

Performance Reporting is now integrated into the editor

Previously, it took some effort to get started with Performance Reporting. These were the steps our beta users went through:

  • Learn the feature existed
  • Go to the website
  • Download the package
  • Install the package
  • Get your project ID
  • Add a few lines of code to your project

While we did our best to simplify this, it was still too hard.

We’re pleased to announce that in Unity Pro 5.4, new projects can enable Performance Reporting with one click.


The work here mostly involved translating C# into C++ , refining our algorithm for sending data and moving from the Unity WWW class to the UnityWebRequest class.

How the Performance Reporting client works

Performance Reporting sends reports with a behavior that works like this:

  • A map between fingerprint and exception is stored.
  • An exception comes in and gets fingerprinted.
  • If the fingerprint isn’t in the map, it is added, then an asynchronous HTTPS request is scheduled for that report ensuring PerfRep gets at least one report.
  • If the fingerprint already exists in the map, a counter is incremented.
  • If too many of the same exception have been observed (10,000), the data is flushed asynchronously via HTTPS, and the feature breaker trips for the session.
  • If too many different exceptions have been observed (100), the data is flushed asynchronously via HTTPS, and the feature breaker trips for the session.
  • When the client exits the game, the data is flushed asynchronously via HTTPS to the server.

When the feature breaker trips, we unregister the log callback so we don’t get any more reports this play through. Relaunching the game will start sending new reports. Usually when you reach one of these limits, you hit one of these cases:

  • There is an exception in the update loop.
  • A message that is variable with something like a time stamp, url with a query string, or temporary file name.

One challenge was the exit hook. Some platforms don’t give you any time; others do. The Desktop platforms will successfully send their final counts, but that might not always be the case with iOS.

Upgrading from the Performance Reporting Plugin

If you’re using Performance Reporting for a 5.3 or earlier project, upgrading  from the plugin to native editor is pretty straight forward. Just remove the package and any code you have referencing it, such as the initializing code. Then go to the Unity Services window shown above and click enable.

If you don’t remove the plugin, the new method will still work. However, both the plugin and editor integration will send a report, causing double counting and extra network traffic.

Performance Reporting Roadmap

The feedback we’ve gotten has been remarkably consistent. Developers want native crashes, and some more filtering and tagging options for the dashboard.

The good news is that we should have some better filtering options for the dashboard SoonTM. The also good, but never soon enough news, is that native crashes will probably be in 5.5 for iOS with other platforms to follow. Native crashes are a platform by platform battle, and we will do our best to get the ones we can into 5.5.

Another shift for Performance Reporting will be the what we’re calling the “Common Data Pipeline”. This is a platform that the editor will use to minimize network connections and link information between services.


June 22

Adding Facial Recognition to Your Mobile Apps

2016-06-21_1746Whether it’s automatically tagging friends in our Facebook photos or “live filters” on Snapchat, facial recognition is increasingly becoming a large part of our everyday lives. Adding facial recognition to software in the past was extremely challenging, however. Now, though, Microsoft Cognitive Services makes it as easy as a few lines of code—for free.

Whether you’re building consumer or enterprise applications, there’s a Microsoft Cognitive Services API that will make your app more innovative and pleasant to use. In this blog post, you’ll learn how to add facial recognition with Microsoft Cognitive Services’s Face APIs to an employee directory app, so we can identify an unknown employee from a photo.

Introducing the Face APIs

Microsoft Cognitive Services lets you build apps with powerful algorithms in just a few lines of code, providing 22 APIs that use artificial intelligence and machine learning to do everything from OCR, to speech and facial recognition. APIs are broken down into five main groups: vision, speech, language, knowledge, and search. The Face APIs from Microsoft Cognitive Services allow you to detect human faces, organize people into groups, find similar faces, and identify previously-tagged faces in images.

Xamarin has grown a ton over the past few years, and sometimes it’s tough to know exactly who everyone is. The great thing about Microsoft Cognitive Services is it’s not only great for innovative apps, but for all types of apps, including apps built for the enterprise. In this blog post, let’s build an employee directory app that identifies an employee from a photo to help ensure I don’t get into an awkward situation at a company party if I don’t know someone I should.

To get started for free, visit the Microsoft Cognitive Services subscription page, and subscribe to the Face APIs. Once registered, you should have a free subscription to the Face APIs, including API keys.

Subscription page for the Face APIs, including API keys.

Download the starter code for the Xamarin employee directory app, which we’ll extend to use facial recognition to identify employees from a photo.

Identifying Employees with Facial Recognition

To identify a person in a photo, we must first train the facial recognition model. Identifying the person in a photo is as easy as these four steps:

  1. Create a person group.
  2. Add people with corresponding faces to that person group.
  3. Train the facial recognition model.
  4. Detect and identify the people in a photo.

Training the Facial Recognition Model

To get started, open EmployeesViewModel and add a new method named RegisterEmployees. We start off by creating a new person group, which is just a container for a group of people. After we’ve created a person group, we need to add people to that group. Each person also needs one or more faces from which we can identify them. Finally, we need to train the person group. This will identify the unique features of a each face that can later be used to identify a person.

async Task RegisterEmployees()
    var faceServiceClient = new FaceServiceClient("{FACE_API_SUBSCRIPTION_KEY}");
    // Step 1 - Create Person Group
    personGroup = Guid.NewGuid().ToString();
    await faceServiceClient.CreatePersonGroupAsync(personGroupId, "Xamarin Employees");
    // Step 2 - Add persons (and faces) to person group.
    foreach (var employee in Employees)
        // Step 2a - Create a new person, identified by their name.
        var p = await faceServiceClient.CreatePersonAsync(personGroupId, employee.Name);
        // Step 3a - Add a face for that person.
        await faceServiceClient.AddPersonFaceAsync(personGroupId, p.PersonId, employee.PhotoUrl);
    // Step 3 - Train facial recognition model.
    await faceServiceClient.TrainPersonGroupAsync(personGroupId);

In production, the process of creating a person group, adding people and faces, and training the model would probably be done on your backend. For example, when you provision a new employee on your backend, a new person (and corresponding face) would automatically be added and the model would be retrained.

Next, call RegisterEmployees from the constructor of the EmployeesViewModel to ensure that we are configuring our facial recognition model at startup. We’re now ready to identify employees!

Facial Detection and Identification

Now that we’ve properly trained our facial recognition model, we can use Microsoft Cognitive Services to identify a person from a photo. Because we’re using the MVVM pattern in our employee directory app, we can use commanding to respond to events on our user interface and execute code in our view model. Navigate to the ExecuteFindSimilarFaceCommandAsync method in EmployeesViewModel, which is a backing method for our command where we’ll write the logic to identify an employee.

First, we need to take a photo from which we can identify an employee. We can use the Media Plugin for Xamarin and Windows to take or select photos from shared code:

MediaFile photo;
await CrossMedia.Current.Initialize();
// Take or select a photo using the Media Plugin for Xamarin and Windows
if (CrossMedia.Current.IsCameraAvailable)
    photo = await CrossMedia.Current.TakePhotoAsync(new StoreCameraMediaOptions
        Directory = "Employee Directory",
        Name = "photo.jpg"
} else {
    photo = await CrossMedia.Current.PickPhotoAsync();

Now that we have a photo, let’s pass that to Microsoft Cognitive Services to identify the employee:

using (var stream = photo.GetStream())
    var faceServiceClient = new FaceServiceClient("{FACE_API_SUBSCRIPTION_KEY}");
    // Step 4a - Detect the faces in this photo.
    var faces = await faceServiceClient.DetectAsync(stream);
    var faceIds = faces.Select(face => face.FaceId).ToArray();
    // Step 4b - Identify the person in the photo, based on the face.
    var results = await faceServiceClient.IdentifyAsync(personGroupId, faceIds);
    var result = results[0].Candidates[0].PersonId;
    // Step 4c - Fetch the person from the PersonId and display their name.
    var person = await faceServiceClient.GetPersonAsync(personGroupId, result);
    UserDialogs.Instance.ShowSuccess($"Person identified is {person.Name}.");

That’s it! All of our facial recognition logic is now complete. Jump over to EmployeesPage.xaml, where we’ll add a ToolbarItem to the navigation bar for users to click on to launch the camera and identify an employee:


We can now identify employees. The great thing about Xamarin.Forms is you can both build great mobile apps that run on iOS, Android, and Windows 10 mobile, but also desktop apps with Xamarin.Forms for UWP. Let’s identify a photo of me using the employee directory app and a Windows 10 laptop:

Wrapping Up

In this blog post, we used Microsoft Cognitive Service’s Face APIs to identify an unknown employee from our employee directory by taking or selecting a photo. To learn more about Microsoft Cognitive Services, watch the “Build ‘Smart’ into your app with Microsoft Cognitive Services” session from Xamarin Evolve 2016. For more examples of using Microsoft Cognitive Services to build smart mobile apps, and to download the complete code for this blog post, check out my smarter-apps GitHub repository.

The post Adding Facial Recognition to Your Mobile Apps appeared first on Xamarin Blog.

June 21

Making Your iOS Apps IPv6 Ready

On June 1, Apple started enforcing a new policy whereby all iOS applications must support IPv6-only network services in iOS 9. While Apple states that most apps will not need to be changed or updated, your app may be using a few libraries that need to be updated before you submit your next update.


Issues and Fixes

Here are some of the most common issues that you may have lingering in your code and how to fix them.

Hard Coded IP Addresses

All newly created IP Addresses will need to be IPv6 or converted to IPv6 if available. Our recommendation is to always use the hostname when possible, but if you are not able to, don’t fear, because it’s super simple with the .MapToIPv6() extension method. This is more of a quick fix, as you’ll never get a pure IPv6 connection; in this case you could also manually convert any IP to a byte array, or simply use IPAddress’s TryParse method to parse any IPv6 address. Additionally, check out some of the nifty methods in System.Net.Dns that can help resolve the IP Address for you if IPv6 is available or not. If you are using HttpClient, BasicHttpBinding, or WebRequests there are no changes needed unless using hard coded IP addresses as discussed above.

There may, of course, be certain older devices that can’t update to support IPv6 and as a developer you are forced to connect using IPv4. If you are stuck in this situation, you’ll have to mention it when submitting your app for review.

Sockets and AddressFamily

When creating .NET Sockets, you’re able to specify the AddressFamily as InterNetworkV6, which will ensure the socket is created using the IPv6 protocol.


var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);


var socket = new Socket(AddressFamily.InterNetworkV6, SocketType.Stream, ProtocolType.Tcp);

Additionally, you can opt not to pass an AddressFamily, in which case Socket will use Dual Mode.

Connectivity Plugin

The Connectivity Plugin for Xamarin and Windows relies on the core reachability sample that Apple created to help developers handle connection state in their app. Since its original release, the reachability sample has been updated and recently the Connectivity Plugin has been updated to be IPv6 compatible. Simply update to the latest release, 2.2.2, and your app will be ready to submit.

Learn More

Be sure to read through the IPv6-only networks announcement from Apple. And their guide on ensuring compatibility with DNS64/NAT64 networks to test an IPv6 network on your Mac.

The post Making Your iOS Apps IPv6 Ready appeared first on Xamarin Blog.

June 20

Podcast: WWDC 2016 Recap

This week on the Xamarin Podcast, Pierce and I cover everything you need to know as a mobile developer from Apple’s WWDC 2016, including new additions and upgrades to iOS, macOS, watchOS, and tvOS.

Subscribe or Download Today

Knowing the latest in .NET, C#, and Xamarin is easier than ever with the Xamarin Podcast! The Xamarin Podcast is available from iTunes, Stitcher, and SoundCloud. Do you have an interesting story, project, or advice for other .NET mobile developers? If so, we’d love to share it with the Xamarin community! Tweet @pierceboggan or @MikeCodesDotNet to share your blog posts, projects, and anything else you think other mobile developers would find interesting. Be sure to download today’s episode on WWDC 2016, and don’t forget to subscribe!

The post Podcast: WWDC 2016 Recap appeared first on Xamarin Blog.

June 17

Contest: Add the Latest in Xamarin.Forms

At Xamarin Evolve 2016 we announced that Xamarin.Forms is now open source and introduced a brand new Xamarin.Forms Previewer that renders a live preview of a page side-by-side with the corresponding XAML markup, directly within your Xamarin Studio environment. Xamarin.Forms has also had tons of new features added in the last several months to help you build great mobile apps even faster, including the introduction of DataPages, native control embedding, URL navigation, and a CarouselView control.

In this contest, we invite you to try out the latest-and-greatest in Xamarin.Forms by adding a Xamarin.Forms 2.* feature to your application to receive a Xamarin code monkey!

How to Enter

  1. Add one of the Xamarin.Forms 2.* features below to your app:
  2. Take a screenshot of the new feature(s) implemented in code alongside your app running on a simulator/emulator, and tweet it with the hashtag #XamarinForms and the Xamarin.Forms 2.* feature added.
  3. Sample tweet:


All submissions must be made by Monday, June 27 at 12:00 pm EDT. A valid entry consists of a tweet containing the hashtag #XamarinForms and mentioning @XamarinHQ, along with a screenshot of a Xamarin.Forms 2.* feature being implemented (picture must contain associated code and feature running in app). Each valid entry will receive a plush Xamarin code monkey, one entry per person. To be eligible, you must follow @XamarinHQ on Twitter to enable us to DM you for private-follow up. There is no purchase necessary to enter the “Add the Latest in Xamarin.Forms” contest.

The post Contest: Add the Latest in Xamarin.Forms appeared first on Xamarin Blog.

WWDC Unity Metal Tessellation Demo

This year, in the “What’s New in Metal” session at WWDC, Apple showed our Unity demo of adaptive tessellation written using Metal. The demo shows a low polygon sphere being tessellated with many more triangles as we shift between materials using displacement mapping, providing beautiful detail of each material.


For this proof of concept, we added Metal Tessellation support to Unity, along with Metal Compute and native Metal shading language support. We can’t wait to ship support for these in future versions of Unity.


Metal Tessellation allows Unity to enable pre-existing tessellation shaders for Metal, yet opens up new possibilities by decoupling the generation of tessellation factors from draw calls. You can either pre-generate them or write a custom compute shader to do it efficiently per draw or as a separate pass. Regardless of how you choose to generate tessellation factors, the rendering pipeline for each draw remains the same,with just a vertex and fragment shader, while accounting for newly generated patches emitted by the tessellator.

For the demo, we wrote a custom per draw “patch kernel” in a native Metal compute shader to calculate a tessellation factor buffer. We then cycled through a bunch of material properties set up in the Unity editor and displaced the triangles emitted by the tessellator in the “post tessellation vertex shader” (also written as a native Metal shader in Unity). The fragment shader is the same physically based Unitystandard shader currently existing in Unity, but with more triangles it really brings out the details in the material.


Tessellation can be used to implement level of detail, efficiently adapt between materials (as in our demo), or for various other effects – limited only by your imagination! While tessellation has been around for a while, we’re excited to see it come to iOS as it can help produce extremely detailed meshes without storing/streaming large meshes on disk.

This is only one of the many features Apple announced for Metal. Some of the others such as Metal Resource Heaps and Memoryless Render Targets, offer potential for performance and memory usage improvements so we are also excited to see what we can do with them. Meanwhile, we look forward to seeing you use Metal Tessellation in your projects, and welcome your feedback!

June 16

Mobile DevOps at Coca-Cola Bottling Co. Consolidated

Mobile-optimized DevOps has never been easier, and it’s setting Xamarin customers apart. With demanding users and high stakes delivery timelines, Coca-Cola Bottling Co. Consolidated’s (CCBCC) DevOps processes help its developers create apps that users love for their ease of use and business stakeholders love for their impact on sales.

Here, Tarandeep Kaur, Sr. ISS Application Architect, shares her experiences and advice in a peek behind the scenes at CCBCC’s DevOps process

Meet Coca-Cola Bottling Co. Consolidated: End-to-End with 100% C# and .NET

Based in North Carolina, CCBCC is the largest independent Coca-Cola bottling distributor in the US, with $1.5B+ in annual revenue and a large field salesforce and customer network. To better serve their sales teams and customers, CCBCC used Xamarin, Visual Studio, Visual Studio Team Services, and Azure to get their Marketplace iPad app into users’ hands in just four months by managing the entire DevOps cycle in C#.

Tell us a little bit about your company and role—have you always been a developer?

As the largest independent Coca-Cola bottler in the US, we make, package, and deliver soft drinks to stores, restaurants, entertainment venues, offices, and college campuses, focusing primarily on the Southeast and Mid-Atlantic regions.

Personally, I’ve been a hands-on developer for eight years, and I’ve been working on mobile projects for about two years. I’m an Application Architect, responsible for technical design, code development processes, and the overall software development lifecycle for our products. I work closely with our development and QA teams, as well as business partners and external vendors.

Tell us about your app. How does it fit into your company’s mobile strategy?

Our Marketplace app is an iOS iPad tool that our field team uses when visiting customers. We designed the app to support our constantly evolving sales and marketing space, as well as facilitate better customer engagement.

Giving our field staff mobile access is especially critical, as they’re often in areas with limited connectivity, and Marketplace makes them efficient from anywhere. Our employees are free to access the systems they need to work without being chained to desktops or hard-wired internet, making them happier and more productive.

Why did you choose Xamarin and Visual Studio to build your apps?

We chose Xamarin because it allowed us to use our in-house C# skills and .NET talent for cross-platform mobile development. Since we knew C#, we were able to minimize the mobile learning curve and expedite development and delivery.

We were able to ship our app—from design to deploy—in just four months. Without Xamarin and Visual Studio, this would have taken much longer due to a huge learning curve for our in-house team.

How did you get up to speed with cross-platform mobile development?

We relied heavily on online resources and augmented our team with a couple of Xamarin developers, who acted as mentors for the rest of the team.

What is the most compelling or exciting aspect of your app (design feature, functionality, etc)? Why?

The intuitive, easy-to-use design has been very valuable for our field reps, with the majority of users able to use the app with little or no training.

What do you think about when you hear “native app”? How did Xamarin and Visual Studio help you accomplish your definition of “native”?

“Native App” usually indicates better performance and a consistent look and feel. Xamarin (specifically Xamarin.Forms) met this definition, allowing us to code in C#, while still maintaining that native look and feel, as well as optimize performance at all times.

For example, using the iOS API was remarkably simple, and we easily incorporated native APIs, like Maps.

Did you integrate with any other services or systems? How did that affect your productivity?

We integrated with Visual Studio Team Service, Raygun, and Slack. We implemented a code review process early on, and the Slack integration helped us stay up to date, even while working across varied geographical locations. We also used Visual Studio Team Service to manage our Agile workflow.

What have your users said about your app? Your manager?

It’s been very well received. Our field users have described the app as “slick,” “intuitive,” “fast,” and “polished.”

What advice do you have for developers who are just starting out or investigating mobile development? Any best resources?

Not being tied to a particular platform is a priceless skill and ability for me, our team, and developers everywhere. Xamarin brings mobile development within reach for the large C# and .NET developer base, without the added time and cost of learning traditional native development platform-specific languages.
Read more about mobile-optimized development here.

The post Mobile DevOps at Coca-Cola Bottling Co. Consolidated appeared first on Xamarin Blog.

Translation parameters in angular-gettext

As a general rule, I try not to include new features in angular-gettext: small is beautiful and for the most part I consider the project as finished. However, Ernest Nowacki just contributed one feature that was too good to leave out: translation parameters.

To understand what translation parameters are, consider the following piece of HTML:

<span translate>Last modified: {{post.modificationDate | date : 'yyyy-MM-dd HH:mm'}} by {{post.author}}.</span>

The resulting string that needs to be handled by your translators is both ugly and hard to use:

msgid "Last modified: {{post.modificationDate | date : 'yyyy-MM-dd HH:mm'}} by {{post.author}}."

With translation parameters you can add local aliases:

<span translate
      translate-params-date="post.modificationDate | date : 'yyyy-MM-dd HH:mm'"
    Last modified: {{date}} by {{author}}.

With this, translators only see the following:

msgid "Last modified: {{date}} by {{author}}."

Simply beautiful.

You’ll need angular-gettext v2.3.0 or newer to use this feature.

More information in the documentation: https://angular-gettext.rocketeer.be/dev-guide/translate-params/.

Comments | More on rocketeer.be | @rubenv on Twitter

Evolution of our products and pricing

A few weeks ago we announced new products and pricing. Some of you were very happy with what were lower prices for you, while others of you were not so happy. There are some things we could have done better and we’ve been working on fixing those.

Firstly, our move to subscription had some of you asking why?! We’ve explained the rationale in the follow-up blog post by Joachim – Subscription! Why?. If you haven’t read it yet, check it out.

Secondly, some of you raised major concerns with the new pricing:

  • Some of you have been customers for a long time and have made use of upgrade discounts to your perpetual licenses. Those averaged to a yearly cost that was lower than the new subscription costs.
  • If you develop for desktop only, the new all-platform cost is significantly higher than your old yearly cost.

For those of you hit hard by this, we think we’ve found a good solution.

Now, we don’t want to go back to the old model of having iOS and Android be paid add-ons, while desktop is included in the base cost. This was always rather arbitrary. Developing and maintaining our desktop platforms is a real cost for us, just like for our mobile platforms, and yet mobile developers have been paying more. Now we’re committed to making the price the same regardless of which platforms you target. We hope you understand and are with us in this decision.

At the same time, a lot of customers are telling us that the new prices are a very good deal. Some have the privilege to even say it’s too cheap, though these people, being happy with the new prices, have not been as vocal in comments and social media.

The objective for us is to make everyone as happy as is possible given a rapidly growing global group of developers using Unity for many, many different things. We want paid versions of Unity to be affordable for developers big and small who want to go beyond Unity Personal, or are required to due to the revenue cap.

So with this goal in mind we are going to make these changes to what we announced previously:

  • We’re making the Unity splash screen in Unity Plus optional, like it is in Unity Pro.
  • We’re raising the revenue cap in Unity Plus from $100k to $200k so that more of you are able to take advantage of it.

In order to be able to do this, we removed the option to subscribe to Unity Plus without a one-year commitment. We also restricted Pay to Own to only apply to Unity Pro and not Unity Plus (see Pay to Own details further down). We let these things go from Unity Plus in order to be able to introduce the new advantages.

We know this is not going to change things for all of you. If your revenue is beyond the $200k cap for Unity Plus, and you are already a Unity user, we’re announcing Transition offers below. We hope though that these changes will make Unity a great choice to those of you who might otherwise have had difficulties affording it.

New splash screen

Apart from price changes, we’re also working on some changes to the Unity splash screen.

The new splash screen will read “Made with Unity” in all editions of Unity – no more mention of “Personal Edition”. You will also be able to customize it with your own (blurred) background image and your own company logo in addition to the Unity logo. This feature is coming, but give us a bit of time to perfect the technical aspects of it before we release it. The customizable splash screen will be available in all versions of Unity, but can be completely turned off in Unity Plus and Unity Pro. We’ll have a blog post with further details later.

Product overview

Unity Personal

  • Free
  • $100k revenue or funding cap
  • All platforms
  • Unity splash screen (with customization options)
  • Personal tier services

Unity Plus

  • Pay $35 per month with 12 month commitment
  • $200k revenue or funding cap
  • All platforms
  • Optional Unity splash screen (with customization options)
  • Dark Editor Skin
  • Plus tier services

Unity Pro

  • Pay $125 per month with 12 month commitment
  • No revenue cap
  • All platforms
  • Optional Unity splash screen (with customization options)
  • Dark Editor Skin
  • Pro tier services
  • Pay to Own

Both Plus and Pro tiers can be paid monthly or upfront (for people who find that easier for budgeting or billing purposes), and require you to commit to at least 12 months of subscription. There will also be an option to commit to Pro for 24 months, for people who want long term price certainty.

Transition offer for existing Unity 5 Pro perpetual license customers

We will launch the new products soon, for new customers to buy. As an existing Unity 5.x perpetual license customer, you will no longer get new updates after March 2017. However, you have a few options if you want to keep getting updates:

  1. For up to five seats, you may subscribe to Unity Pro at the special price of $75 per month for a limited transition period, after which the price will revert to the normal subscription price of $125 per month:

    • If Unity 5 Pro is your first version of Unity, your transition period is one year.
    • If you owned Unity 4 Pro, your transition period is two years.
  2. If you make less than $200k per year, you may choose Unity Plus and pay $35 per month with an annual commitment.

We will start sending out these transition offers by email after the new products have launched in our store. 

Pay to Own for Unity Pro

If you pay for 24 or more consecutive months of a new Unity Pro subscription, you get to keep and use the version you have when you notify us that you are stopping subscription and choosing pay to own. At such point, you will stop receiving access to Pro tier services, new features and upgrades. You will receive the next 3 patches. We reserve the right to grant access to additional patches in the event that we find severe bugs. If you later resume the subscription, you will still own the perpetual license you elected but again start receiving updates, fixes and services. Once you have subscribed for another 24 consecutive months, and should you then elect to cease this new subscription, you will then be granted a new perpetual license of the then current version of Unity.

Thanks for taking the time to read all the detail. Please let us know your thoughts.

For more information

Read the updated Unity Subscription FAQ.

Talk to us about the new licensing on the forum.

June 15

Flip through items with Xamarin.Forms CarouselView

TheCarousel latest preview release of Xamarin.Forms (2.3.0) includes some great new features, including Themes, Data Pages, URL Navigation, and a brand new control, the CarouselView. You can think of the CarouselView as the successor to the CarouselPage, which had the restriction of a page that couldn’t be embedded easily. In contrast, the new CarouselView is highly optimized on each platform, allowing you to flip through many items with a simple, familiar API with an ItemsSource and a DataTemplate.

Get the CarouselView

Ensure that your projects are on the latest version of Xamarin.Forms and then install the CarouselView NuGet in your iOS, Android, Windows, and Portable Class Library (if applicable).


There are many use cases for the CarouselView; the top one that I hear is having a Carousel on the top of a page to show off specific items, as seen in the app stores. For this example, we’re going to take an existing application that includes a list of monkeys and add a CarouselView to the top that highlights zoos where you can see them.

A zoo is represented by an image and name:

public class Zoo
    public string ImageUrl { get; set; }
    public string Name { get; set; }

In our View Model that will be set to the BindingContext of the page, we have an ObservableCollection of Zoo items:

public class MonkeysViewModel
    public ObservableCollection Monkeys { get; set; }
    public ObservableCollection> MonkeysGrouped { get; set; }
    public ObservableCollection Zoos { get; set; }
    public MonkeysViewModel()
        Monkeys = MonkeyHelper.Monkeys;
        MonkeysGrouped = MonkeyHelper.MonkeysGrouped;
        Zoos = new ObservableCollection
            new Zoo
                ImageUrl = "http://content.screencast.com/users/JamesMontemagno/folders/Jing/media/23c1dd13-333a-459e-9e23-c3784e7cb434/2016-06-02_1049.png",
                Name = "Woodland Park Zoo"
                new Zoo
                ImageUrl =    "http://content.screencast.com/users/JamesMontemagno/folders/Jing/media/6b60d27e-c1ec-4fe6-bebe-7386d545bb62/2016-06-02_1051.png",
                Name = "Cleveland Zoo"
            new Zoo
                ImageUrl = "http://content.screencast.com/users/JamesMontemagno/folders/Jing/media/e8179889-8189-4acb-bac5-812611199a03/2016-06-02_1053.png",
                Name = "Phoenix Zoo"

Adding the CarouselView

Since the CarouselView is in a separate assembly, we must bring in the CarouselView’s namespace in root of our page:


Then we can simply add the CarouselView at the top of our page:


CarouselView In Action

As you can see, the CarouselView has an ItemsSource with a binding to the ObservableCollection that we created. Each zoo then has its own DataTemplate to display the its logo and name.

Windows Setup

If you are building applications for Windows, a DataTemplate needs to be added to the Application Resources in the App.xaml of the application.

First add a new namespace in the root node:


Then add the following to the Application.Resources node:


It should look something like this:


CarouselView Events

Since the CarouselView is a control, you have access to a wide variety of animation and life cycle events that you would expect, but you can also subscribe to the ItemSelected event to see when users flip through the view:

CarouselZoos.ItemSelected += (sender, args) =>
  var zoo = args.SelectedItem as Zoo;
  if (zoo == null)
  Title = zoo.Name;

Embed Anywhere

Since the CarouselView is a view, you can put it anywhere on the page or even inside of the ListView’s header so it scrolls with the ListView:



Learn More

To learn more, be sure to read through all of our updated documentation for Xamarin.Forms 2.3.0 and of course browse the full source code for this sample on GitHub.

The post Flip through items with Xamarin.Forms CarouselView appeared first on Xamarin Blog.

The Made with Unity Developer Story Contest

We’ve seen some amazing stories since the launch of madewith.unity.com and learned about some amazing upcoming projects that may have otherwise not been on our radar. We’re happy to say we’ve reached over 250 developer stories on the site to date! We’re celebrating this milestone by rewarding the next 10 awesome stories with a ticket to Unite 16 in Los Angeles ($475 value). Read on below to learn how you could be one of the potential winners!


  • We’re running a contest that spans over a 3 week period starting June 15 through July 6 in search of the next 10 great developer stories. Winners are announced on July 14.
  • 10 developers will receive one free ticket to Unite 16
  • All stories published within the contest period are automatically entered
  • Your chances for winning are increased when your story is shared across Facebook and Twitter
  • Final judgement is based on presentation and quality of writing. Winners are announced the week after the contest ends.


There’s way more than ten great stories on the site, but these are the ones that stood out, taught us something we otherwise would never have known about their game, provided lessons for Unity developers to follow, or displayed some awesome behind the scenes perspective. Coincidentally, they also applied our general guidelines in some shape or form. Here’s a list of our ten favorites (in order of published date).


In celebration of how far we’ve come in such a short period of time we want to award the next ten great stories published on madewith.unity.com. Starting Wednesday, June 15 through July 6, we’re looking for 10 new awesome stories and reward the authors with a free pass to Unite 16 which includes access to our many developer sessions, annual Unite Awards ceremony, MWU Showcase, and more!

If you’ve written and published a story that week (and you follow the rules outlined below), you’re automatically entered. Prizes are limited to one Unite pass per development team (or solo indie if you’re doing all the work yourself). However, you MAY use a recent blog post from your personal devblog so long as it meets the below requirements. If you’re working on something amazing please share it!

We’ll announce the ten winners on Thursday, July 14 on madewith.unity.com, MWU social channels, and directly to winners via email.


  • Must have an approved MWU Game Profile and the game must be either in some form of release or active development (e.g. early access, alpha, beta, final release).
  • Story must be related to a game made with Unity by you or your team
  • Story must be written in English
  • Story must be published within the contest period (Wednesday, June 15 00:01 PDT through Wednesday, July 6 23:59 PDT)
  • Criteria for selection is weighted by how much the story was shared, number of unique views, and editorial review (share as much as possible!)
  • Editorial review is based on the following:
    • Articulate and well written
    • Incorporates images and media
    • Tells us something about your game and/or its development (check out our guidelines for some inspiration)
  • You MAY use content you previously written on another blog so long as it meets the above requirements
  • Ten winners will be notified at 15:00 PDT on Thursday, July 14
  • Winners are notified via email and announced on MWU social channels, email, and madewith.unity.com
  • An individual or team may not win more than once (i.e. if you submit 40 awesome stories, only one is eligable to win one pass)
  • For full terms and conditions of the contest, please go here


If you’ve already signed up at madewith.unity.com and created an approved Developer Profile, all you need to do is log in, create a new story, and publish, and promote your story to your social network.

For those of you who haven’t created a game profile yet, it’s available to all developers who have a game or games they’re developing with Unity. Head to http://madewith.unity.com/tell-your-story and assign it to a Unity ID. After you’ve created a Developer Profile, we’ll approve it pending a short review process to verify you’re a real person and working on a real project. From there you’re able to create new Game Profiles for the site and start writing your story.

We encourage everyone to use it as a development blog and share what you’re working on with the rest of the community. If you’re looking for inspiration, check out one of the many staff picks and refer to our ten current favorites!


Our goal on the Made with Unity team is to create new discovery opportunities for our developer community and help them find new audiences. Discovery is an ambitious problem to solve and we’re dedicated to find new ways to support you.

We consider madewith.unity.com as the beginnings of a content hub for our community that allows us to learn and expand new areas for promotion. We’ve already learned about some new amazing games that may have otherwise not been on our radar or known it was made with Unity. We’ve also shared information with platform partners and sponsors and plan to use it as the basis of participation in our Unite Showcases and other industry events.

You’ve given us a lot of great feedback and we’ll start to roll out updates later this summer so we can make it a better experience for you.

We can’t wait to see the great things you’re working on!

The Made with Unity Team

June 14

WWDC 2016 Recap for iOS Developers

Yesterday, Apple announced several exciting innovations during the WWDC keynote presentation to kick off Apple’s annual developer conference. No matter what Apple platform your building for today, there’s an update that will provide you with brand new APIs and features to explore.


iOS 10

Let’s start off with Apple’s most popular platform, iOS. This year we’ve seen Apple announce iOS 10 (sadly not iOS X as I’d secretly been hoping for) which has some existing OS features being made available to app developers.


Apple have created a new set of Siri APIs for developers to consume dubbed ‘SiriKit’, which allow apps that provide specific services to use the digital assistant. These services are currently limited to:

  • Audio or video calling
  • Messaging
  • Sending and receiving payments
  • Searching photos
  • Booking a ride
  • Managing workouts

To make use of SiriKit, you’ll need to create one or more App extensions using the Intents framework of iOS. When a user makes a request involving your service, SiriKit will send your extension an intent object describing the data relating to the request.


Following the SiriKit approach of using extensions, we’re also now able to create extensions for iMessage. These could be something simple like a sticker pack (which requires no code, so we’ll be seeing a lot of these) or the more adventurous may be interested in creating a custom UI, which can be displayed within the Messages app.



iOS introduces a brand new framework for user notifications, which supports handling both local and remote notifications. It’s possible to schedule notifications based on specific conditions such as geo-fencing or time.

In addition to the new framework for handling notifications, we’ve also been given access to the notification UI framework that allows us to customize the appearance of notifications.

You’ll want to familiarize yourself with the new APIs if your existing app uses notifications, as many of the existing notifications APIs for iOS 9 or older are now deprecated.

Other exciting additions

There have been enhancements all over iOS that will subtly change the way we write our mobile apps. Such improvements include a new animation API: Core Image now supports RAW and Core Motion now supports pedometer events. You can find new APIs in HealthKit, HomeKit, Metal, Foundation, Core Motion, AVKit, Core Data, and many more.

If you’re a game developer, you’ll be pleased to hear that Apple now includes several frameworks that exist on other platforms such as SceneKit. SceneKit allowing you to create 3D models that make use of a high-performance rendering engine, all from one easy to use API.

watchOS 3

As an Apple Watch user, watchOS 3 is probably the most exciting release of the day. It sees huge performance increases in app performance from 3rd parties, which has been the biggest issue with developing for the Watch.

The new version of the OS does include some new APIs, including the ability to interact with the digital crown and add support for in-app payments.


You read that right: after 15 years, Mac OS X finally has a new name, macOS. Not only is there a new name, but a whole new version called macOS Sierra with a bunch of new features packed in for developers.


The biggest of these features is that Siri will now be on your desktop, which opens up some interesting capabilities if SiriKit, available on iOS 10, comes to macOS. Today, you can start by taking advantage of the new contacts API, live photo editing, and the universal clipboard that enables your apps to copy and paste content from your macOS to iOS devices seamlessly!

The post WWDC 2016 Recap for iOS Developers appeared first on Xamarin Blog.

Plastic vs Git - rerere and rebase

It happens quite often -- teams moving away from Git to Plastic ask me what happens with features like rebase and even commands like rerere. They normally jump to Plastic because of the big files, the GUIs, but they want to ensure that they won’t miss any of the things they love in Git.

This blogpost tries to answer these questions, and more specifically: why you won't miss Git-style rebase (or history rewriting entirely) nor rerere in Plastic.

And it all lies in how Plastic handles branching differently than Git...

June 13

Podcast: Xamarin Studio 6, Cycle 7, and more!

This week on the Xamarin Podcast, Mike and I break down the latest major stable release of Xamarin, Cycle 7, which includes the brand-new Xamarin Studio 6, Visual Studio 4.1, and updates to Xamarin.iOS, Xamarin.Android, Xamarin.Mac, and Mono.

Subscribe or Download Today

Knowing the latest in .NET, C#, and Xamarin is easier than ever with the Xamarin Podcast! The Xamarin Podcast is available from iTunes, Stitcher, and SoundCloud. Do you have an interesting story, project, or advice for other .NET mobile developers? If so, we’d love to share it with the Xamarin community! Tweet @pierceboggan or @MikeCodesDotNet to share your blog posts, projects, and anything else you think other mobile developers would find interesting. Be sure to download today’s episode on Cycle 7, and don’t forget to subscribe!

The post Podcast: Xamarin Studio 6, Cycle 7, and more! appeared first on Xamarin Blog.

The Best of dotnetConf 2016 for Mobile Developers

This year’s dotNetConf, a worldwide virtual .NET conference, was the biggest and best yet! dotNetConf ran for three full days of free amazing content for all .NET developers. Each day provided something unique, and started with a full day of ASP.NET, a full day of mobile and IoT, and wrapped up with a full community day. All of the videos are available right now to stream on Channel9, but for mobile C# developers we have highlighted the the top sessions you should watch, starting with Miguel de Icaza’s Day 2 keynote.

Xamarin developer evangelist James Montemagno followed Miguel up by giving a complete walkthrough of the Xamarin platform to build native iOS, Android, and Windows apps in C# that combined Microsoft Cognitive Services and Plugins for Xamarin for a great demo!

Nina Vyedin, Product Manager at Xamarin, wrapped up Day 2 by highlighting some amazing new features in Xamarin.Forms to help developers do more with less.

So Much More!

The Xamarin goodness didn’t stop there as Microsoft’s Adrian Hall walked through setting up Azure Mobile Apps with Xamarin apps, and Xamarin MVP Greg Shackles tackled real world monitoring for your mobile apps in the wild. Be sure to check out all of the other great sessions at dotnetConf 2016 and be on the lookout for the all new in person event, dotnetConf.local, coming to a city near you soon. Head over to dotnetConf.net for all the details.

The post The Best of dotnetConf 2016 for Mobile Developers appeared first on Xamarin Blog.

2D Experimental Preview

We are extremely excited to announce the 2D Experimental Preview! This is an early access version, so you can try out all the new features being developed by the 2D team. And it’s available to everyone!

The purpose of the 2D Experimental Preview build and forum is to provide our community a way to experience new and experimental 2D features that are in development and participate in the development through discussions and feedback. Community feedback is valuable to us as it will help us gauge the usefulness of features and if we are headed in the right direction.

We are calling it Experimental Preview because, instead of just releasing a preview of features in development, we also want to include experiments or prototypes of ideas, so we can get feedback at a very early stage.


9-Slice Sprites

9slice9-Slice is a 2D technique which allows you to reuse an image with variable dimension without preparing multiple assets. Defined areas of an image can be stretched or repeated when an image dimension changes. This technique is commonly used in UI and we have brought this over to sprites as well. It works great for a variety of things, like creating platforms or backgrounds very quickly while using a small amount of texture memory.

Outline Editoroutlineeditor

The Outline Editor is a new addition to the Sprite Editor Window providing the ability to either automatically generate a selectable level of tessellation or manually edit the mesh shape of the sprite.

sortinggroupSorting Group

The Sorting Group Component provides the ability to render a set of objects separately from others on the same Sorting Layer. It ensures that all renderers that are children of the sorting group are sorted together for rendering. This is extremely useful in cases where the amount and order of the Sorting Layers becomes very complex to manage.

Sprite Maskspritemask

Masks are great for either hiding or revealing portions of sprites and have many applications including making cool transition effects. That is why we have also added an alpha threshold control to it. Two types of masks are available, Global Masks that affects the scene, and Scoped Masks which work within a GameObjects hierarchy.

2D Physics

physics2dWe have added quite a few new things for 2D Physics as well. There is now a CapsuleCollider2D Component. This removes the need to use multiple colliders to make a capsule shape and is more optimized as well. We have also added an Edge-Radius property for BoxCollider2D & EdgeCollider2D components, a new 2D Physics Casting API and a new 2D Contacts API, in addition to numerous improvements to 2D Physics.

Tile Map

tilemapThe Tile Map starts with a new Grid Component to specify a tile layout and comes with preset layouts such as Rectangular, Isometric and Hexagonal. Layers are then used to place tiles and this provides the ability to use multiple layers that can be translated or tinted differently. The Tile Map uses a Tile Map Palette for easy access to groups of tiles as well as tile painting tools. A key feature for tiles is the Tile Asset which provides many options such as attaching prefabs to tiles and also programmable tiles.


Head over to the 2D Experimental Preview Forum to grab the latest release and try it out. Give us feedback, suggestions, ask questions, start discussions, make some noise. Be part of developing these new 2D features!


Monologue is a window into the world, work, and lives of the community members and developers that make up the Mono Project, which is a free cross-platform development environment used primarily on Linux.

If you would rather follow Monologue using a newsreader, we provide the following feed:

RSS 2.0 Feed

Monologue is powered by Mono and the Monologue software.