I am hiring software developers.
We are growing our Xamarin Studio/MonoDevelop, Visual Studio, iOS and Android teams.
Ideally, you are a C# programmer and ideally, you relocate to Boston, MA. But we can work with remote employees
Posted on 22 Aug 2013
Those of you that saw my What is in Mono presentation at MonkeySpace know that there is a new language in the .NET world being developed by Zynga called PlayScript.
Check their home page on GitHub with cute videos!
PlayScript is a superset of ActionScript and it was based on Mono's C# 5.0 compiler. PlayScript is ActionScript augmented with C# 5.0 features.
Zynga's PlayScript allows developers that have some ActionScript/Flash code to bring their code to any platform that supports the ECMA Intermediate Language (Microsoft .NET and Mono) and blend it with other .NET languages.
But the PlayScript has a fabulous feature, it allows mixing code in both C# and PlayScript in the same compilation unit. For example, you can use the compiler like this:
# Compile the C# source foo.cs into foo.exe $ mcs foo.cs # Compile the Playscript source bar.play into bar.exe $ mcs bar.play # Compile both C# and Playscript into a single executable $ mcs foo.cs bar.play
On a larger scale, you can see this in action in the pscorlib library. This library contains a blend of PlayScript and C# source code compiled into a single binary.
They have implemented the accelerated 3D APIs from Flash and ported some popular ActionScript libraries to PlayScript, like the Starling framework and Away3D.
They have also an add-on for Xamarin Studio that you can use to get IDE support for it.
At Xamarin we are working to integrate their language changes into Mono directly. You can track the integration work in the playscript-mono branch at GitHub.
Just like Unity's UnityScript, developers will be encouraged to use strong types to improve the performance of their applications.
You can join the PlayScript forum to track the progress of the project. And you can keep up with exciting developments.
Update: Some background on Playscript.
Posted on 20 Aug 2013
Slides from my MonkeySpace "What is new in Mono?" talk:
Posted on 20 Aug 2013
This week, as I was preparing my presentation on C# sung on iOS and Android, I came to the realization that callback-based programming has somehow become an acceptable programming model.
It has become an acceptable programming model, in the same way that using IF/GOTO to write programs was an acceptable model back in the 60's. They are acceptable because we did not have anything better to replace them.
Today, both C# and F# support a programming model that will do to our generation what structured programming, high-level languages and control flow primitives did to the developers in the 60's.
Sadly, many developers when they hear the word "C# async" immediately think "I have callbacks in my language already". Variations of this include "Promises are better", "Futures is the way to go", "Objective-C has blocks" and "the operating system provides that". All of these statements are made by people that have yet to study C# async or to grasp what it does.
This is my attempt at explaining why the C# async model is such a leap forward for developers.
Callbacks have improved significantly over the years. In the pure C days, if you wanted to use callbacks, you would have to write code like this:
void cback (void *key, void *value, void *user_state)
{
// My data is stored in the user_state, fetch it
// in this case, just a simple int.
int *sum = (int *) user_state;
*sum = *sum + *(int *)value;
}
int sum_values (Hashtable *hash)
{
int sum = 0;
hash_table_foreach (hash, cback, &sum);
return sum;
}
Developers would have to pass around these pointers to the state that they managed manually, which is just very cumbersome.
Today with languages that support lambdas, you can write code instead that can capture the state, so things like the above become:
int sum_values (Hashtable hash)
{
int sum = 0;
hash.foreach ((key, value) => { sum += value; });
return sum;
}
Lambdas have made writing code a lot simpler, and now we see this on UI applications that use events/lambdas to react to user input and Javascript apps on the browser and the client that use callbacks to get their job done.
In Node.js's case the original idea was to scale a server by removing blocking operations and instead offering a pure callback-driven model. For desktop applications, often you want to chain operations "on response to a click, download a file, then uncompress it, then save it to the location specified by the user", all while interleaving some bits of user interface and background operation.
This leads to nested callbacks after callbacks, where each indentation level is executing at some point in the future. Some people refer to this as Callback Hell.
During this week preparation, Marco Arment happened to tweet this:
Block enumerators + flatdacted URL sessions + SQLite thread safety = comically deep block calls. http://t.co/XI98RQiE6c
— Marco Arment (@marcoarment) August 9, 2013
This is a common idiom. On our web site, when we launched Async, we shared this sample:
private void SnapAndPost ()
{
Busy = true;
UpdateUIStatus ("Taking a picture");
var picker = new Xamarin.Media.MediaPicker ();
var picTask = picker.TakePhotoAsync (new Xamarin.Media.StoreCameraMediaOptions ());
picTask.ContinueWith ((picRetTask) => {
InvokeOnMainThread (() => {
if (picRetTask.IsCanceled) {
Busy = false;
UpdateUIStatus ("Canceled");
} else {
var tagsCtrl = new GetTagsUIViewController (picRetTask.Result.GetStream ());
PresentViewController (tagsCtrl, true, () => {
UpdateUIStatus ("Submitting picture to server");
var uploadTask = new Task (() => {
return PostPicToService (picRetTask.Result.GetStream (), tagsCtrl.Tags);
});
uploadTask.ContinueWith ((uploadRetTask) => {
InvokeOnMainThread (() => {
Busy = false;
UpdateUIStatus (uploadRetTask.Result.Failed ? "Canceled" : "Success");
});
});
uploadTask.Start ();
});
}
});
});
}
The problem with these nested callbacks is that you can see very quickly that these are not code bases you want to be working with. Currently it does some basic error handling, but it does not even attempt to do some better error recovery.
Thinking about extending the above functionality makes me pause, perhaps there is something else I can do to avoid patching the above function?
And if I wanted to do better error recovery or implement a better workflow I can see myself annoyed at both the bookkeeping that I need to do, make sure that "Busy" value is property updated on every possible exit (and possible exits I add).
This is ugly to the point that your mind starts to wander "perhaps there is a new article on hacker news" or "did a new cat get posted on catoverflow.com?".
Also notice that in the sample above there is a context switching that takes place on every lambda: from background threads to foreground threads. You can imagine a real version of this function being both larger, getting more features and accumulating bugs in corner cases that were not easily visible.
And the above reminded me of Dijkstra's Go To Statement Considered Harmful. This is what Dijkstra's had to say in the late 60's about it:
For a number of years I have been familiar with the observation that the quality of programmers is a decreasing function of the density of go to statements in the programs they produce. More recently I discovered why the use of the go to statement has such disastrous effects, and I became convinced that the go to statement should be abolished from all "higher level" programming languages (i.e. everything except, perhaps, plain machine code). At that time I did not attach too much importance to this discovery; I now submit my considerations for publication because in very recent discussions in which the subject turned up, I have been urged to do so.
My first remark is that, although the programmer's activity ends when he has constructed a correct program, the process taking place under control of his program is the true subject matter of his activity, for it is this process that has to accomplish the desired effect; it is this process that in its dynamic behavior has to satisfy the desired specifications. Yet, once the program has been made, the "making" of the corresponding process is delegated to the machine.
My second remark is that our intellectual powers are rather geared to master static relations and that our powers to visualize processes evolving in time are relatively poorly developed. For that reason we should do (as wise programmers aware of our limitations) our utmost to shorten the conceptual gap between the static program and the dynamic process, to make the correspondence between the program (spread out in text space) and the process (spread out in time) as trivial as possible.
And this is exactly the kind of problem that we are facing with these nested callbacks that cross boundaries.
Just like in the Go To days, or the days of manual memory management, we are turning into glorified accountants. Check every code path for the proper state to be properly reset, updated, disposed, released.
Surely as a species we can do better than this.
And this is precisely where C# async (and F#) come in. Every time you put the word "await" in your program, the compiler interprets this as a point in your program where execution can be suspended while some background operation takes place. The instruction just in front of await becomes the place where execution resumes once the task has completed.
The above ugly sample, then becomes:
private async Task SnapAndPostAsync ()
{
try {
Busy = true;
UpdateUIStatus ("Taking a picture");
var picker = new Xamarin.Media.MediaPicker ();
var mFile = await picker.TakePhotoAsync (new Xamarin.Media.StoreCameraMediaOptions ());
var tagsCtrl = new GetTagsUIViewController (mFile.GetStream ());
// Call new iOS await API
await PresentViewControllerAsync (tagsCtrl, true);
UpdateUIStatus ("Submitting picture to server");
await PostPicToServiceAsync (mFile.GetStream (), tagsCtrl.Tags);
UpdateUIStatus ("Success");
} catch (OperationCanceledException) {
UpdateUIStatus ("Canceled");
} finally {
Busy = false;
}
}
The compiler takes the above code and rewrites it for you. There is no longer a direct mapping between each line of code there to what the compiler produces. This is similar to what happens with C# iterators or even lambdas.
The above looks pretty linear. And now, I can see myself feeling pretty confident about changing the flow of execution. Perhaps using some conditional code that triggers different background processes, or using a loop to save the picture in various locations, or applying multiple filters at once. Jeremie has a nice post that happens to do this.
Notice that the handling of that annoying "Busy" flag is now centralized thanks to the finally clause. I can now guarantee that the variable is always properly updated, regardless of the code path in that program and the updates that take place to that code.
I have just delegated the bookkeeping to the compiler.
Async allows me to think about my software in the very basic terms that you would see in a flow-chart. Not as a collection of tightly coupled and messy processes with poorly defined interfaces.
The C# compiler infrastructure for Async is actually built on top of the Task primitive. This Task class is what people in other languages refer to as futures, promises or async. This is probably where the confusion comes from.
At this point, I consider all of these frameworks (including the one in .NET) just as lower-level plumbing.
Tasks encapsulate a unit of work and they have a few properties like their execution state, results (if completed), and exceptions or errors that might have been thrown. And there is a rich API used to combine tasks in interesting ways: wait for all, wait for some, combine multiple tasks in one and so on.
They are an important building block and they are a big improvement over rolling your own idioms and protocols, but they are not the means to liberate your mind. C# async is.
Today I had the chance to field a few questions, and I wanted to address those directly on my blog:
Q: Does async use a new thread for each operation?
A: When you use Async methods, the operation that you requested is encapsulated in a Task (or Task<T>) object. Some of these operations might require a separate thread to run, some might just queue an event for your runloop, some might use kernel asynchronous APIs with notifications. You do not really know what an Async method is using behind the scenes, that is something that the author of each user will pick.
Q: It seems like you no longer need to use InvokeOnMainThread when using Async, why?
A: When a task completes, the default is for execution to be resumed on the current synchronization context. This is a thread-local property that points to a specific implementation of a SynchronizationContext.
On iOS and Android, we setup a synchronization context on the UI thread that will ensure that code resumes execution on the main thread. Microsoft does the same for their platforms.
In addition, on iOS, we also have a DispatchQueue sync context, so by default if you start an await call on a Grand Central Dispatch queue, then execution is resumed on that queue.
You can of course customize this. Use SynchronizationContext and ConfigureAwait for this.
Finally, the PFX team has a good FAQ for Async and Await.
Here are some good places to learn more about Async:
Posted on 15 Aug 2013
Like Richard Dawkins, I am also an atheist. I have also enjoyed his books and I am peripherally aware of his atheist advocacy.
Recently a letter Richard Dawkins wrote to his 10 year old daughter made the rounds.
He needs to ammend the letter and explain to her that it is not enough to find evidence, it is also important to be able to reason effectively about this evidence and avoid a series of logical pitfalls.
He failed to do this in a series of poorly thought out tweets, starting with this:
All the world's Muslims have fewer Nobel Prizes than Trinity College, Cambridge. They did great things in the Middle Ages, though.
— Richard Dawkins (@RichardDawkins) August 8, 2013
He followed up with a series of tweets to try to both explain the above as well as retweeting various people that came out in his defense with statements like:
It's embarassing that we live in a society so irrational that even the observation of basic facts can result in outrage. @RichardDawkins
— The Blue Baron (@Ryan__Blake) August 8, 2013
I found the entire episode unbecoming of a scientist.
His original tweet, while true, does not have the effect of trying to advance our understanding of the world. It is at best a troll.
We expect from scientists to use the processes, techniques and tools of science math and logic to advance our understanding of the world, not resort to innuendo, fallacies and poor logical constructions to prove our points.
Among others, I do not expect a scientist to imply that correlation implies causation. Which is what this tweet did.
Today he posted a large follow up where he explains what lead him to make this statement and also to selectively address some of the the criticism he received. He addressed the simpler criticism, but left out the meaty ones (you can find them on the replies to his tweet).
Dawkins failed to address the major problem with his tweet, which was exactly the use of correlation to imply causation.
Instead, he digs down deeper:
Twitter's 140 character limit always presents a tough challenge, but I tried to rise to it. Nobel Prizes are a pretty widely quoted, if not ideal, barometer of excellence in science. I thought about comparing the numbers of Nobel Prizes won by Jews (more than 120) and Muslims (ten if you count Peace Prizes, half that if you don't). This astonishing discrepancy is rendered the more dramatic when you consider the small size of the world's Jewish population. However, I decided against tweeting that comparison because it might seem unduly provocative (many Muslim "community leaders" are quite outspoken in their hatred of Jews) and I sought a more neutral comparison as more suitable to the potentially inflammable medium of Twitter. It is a remarkable fact that one Cambridge college, Trinity, has 32 Nobel Prizes to its credit. That's three times as many as the entire Muslim world even if you count Peace Prizes, six times as many if you don't. I dramatised the poverty of Muslim scientific achievement, and the contrast with their achievements in earlier centuries, in the following brief tweet: "All the world's Muslims have fewer Nobel Prizes than Trinity College, Cambridge. They did great things in the Middle Ages, though."
Now we know that Richard was not merely stating a couple of facts on his original tweet. He was trying to establish a relationship between a religion and scientific progress.
One possible explanation that does not involve Muslim-hood is that the majority of muslims live in impoverished nations (see map). Poverty and access to resources are likely bigger reasons for the lack of advancement in the sciences than belonging to a particular religion.
Is my theory better than Richard's? We could test the theory by looking at the list of Nobel laureates per country.
Let us consider my country, Mexico, a poor country compared to the wealth of the UK. We have twice as many people living in Mexico compared to the UK. Sadly, we only have three Nobel laureates vs Trinity College's thirty two.
If we expand the scope to Latin America which has half a billion people. Even with this, we can only muster sixteen laureates vs Trinity's 32.
Let us look into the African continent, with its billion people. They manage to only score 20 Nobel laureates.
And shockingly, the wealthier the nation, the more laureates. South Africa accounts for half of Africa's laureates (with ten), Egypt which has a better economy than most other African nations and gets tasty American aid gets five, which leaves another five for the rest of the continent.
If I had some axe to grind against Mexicans, Spanish speakers, Africans, Muslims, Bedouins, Brazilians, or Latin Americans I could probably make a statement as truthful as Richard's original tweet, which could be as offensive to those popuations and just like Richard prove absolutely nothing.
I think we have stronger evidence that access to wealth has an effect on how many people get this award than a religion.
The second flaw in his argument is to identify a University with access to funds, and a fertile ground for research and education to a group of people linked only by religion.
Perhaps people go to places like Trinity College becasue it is a fertile ground for research and education. If that is the case, then we have an explanation for why Trinity might have more Nobel laureates.
Luckily, Cesar Hidalgo's research on understanding prosperity shows what we intuitively know: that economic development clusters around existing centers. That is why actors, writers and directors move to LA, financiers move to New York and why companies ship their high-end phone manufacturing to China. You go where there is a fertile ground. Richard, instead of reading the long papers from Cesar, you might want to watch this 17 minute presentation he did at TEDx Boston.
So is Trinity one of these clusters? Can we find other clusters of research and expect them to have a high concentration of Nobel prize laureates? Let me pick two examples, MIT which is next door to my office has 78 laureates and I used to hang out at Berkeley because my mom graduated from there, and they have 22.
So we have three universities with 132 Nobel laureates.
The following statement is just as true as Richard's original tweet, and as pointless as his. Except I do not malign a religion:
All the world's companies have fewer Nobel Prizes than Universities do. Companies did great things in the Middle Ages though.
In fact there is a universe of different segments of the population that have fewer Nobel Prizes as Trinity. And every once in a while someone will try to make connections just like Richard did.
People will make their cases against groups of people based on language, race, sexual preferences, political orientation, food preferences, religion or even what video games they play.
We can not let poor logic cloud our judgement, no matter how importants our points are.
I agree with Richard that I want less religion in this world, and more science-based education. But if we are going to advocate for more science-based education, let us not resort to the very processes that are discredited by science to do so.
We now know that Richard could just not stomach someone saying "Islamic science deserves enormous respect" and this is why he launched himself into this argument.
I can only guess that this happened because he was criticizing religion or Islam and someone told him "Actually, you are wrong about this, Islam contributed to X and Y" and he did not like his argument poked at.
The right answer is "You are correct, I did not consider that" and then try to incorporate this new knowledge into having a more nuanced position.
The answer is not to spread a meme based on a fallacy.
Posted on 09 Aug 2013