Did Microsoft just become viable again?

It would seem that Satya Nadella is the CEO Microsoft needed after BG stood down, his focus on mobile and the cloud have brought the company back into the conversation, in much the same way as the iMac did for Apple.

So do MS have the equivalent of the iPod, something that will propel them back into the limelight and put everyone else on the back foot? Maybe!

 By announcing the open sourcing of .NET, beyond the extant Mono stack, Microsoft will not only shore up their enterprise presence but potentially establish .NET as a first class citizens in the startup world.

The only question is, can they overcome their questionable reputation amongst the Silicon Valley crowd, but with Apple and Google suffering their own reputation issues, Microsoft may be ready to not only regain its technical reputation but, perhaps, establish itself as a the first choice for those seeking open platforms.

It'll be interesting to see if he can keep them on track.

Apple just gave Android a Swift kick in the arse!

WWDC 2014's most exciting announcement, at least as far as I am concerned was the Swift programming language.

IMHO the one thing about iOS that intimidates external developers is Objective-C; with it's strange syntax, bolted on features, and sometimes complex memory management, it feels alien to most.

By contrast the Android alternative is the comfortable, although verbose, Java programming language.

But that was then, this is now; recently a great deal of FUD has arisen around Android and Java because Oracle and their predilection of being, well, Oracle, and, more importantly, Swift.

I hate long posts, so I am not going to review Swift here, Graydon Hoare and Chris Lattner's peeps do a much better job than I ever could, but sufficeth to say that Swift brings into sharp relief the walking cane that Java has been leaning on, these many years. (The last three words must be said in the voice of Richard Harris's Dumbledore)

If someone over at Google is not running around with their hair on fire, I can probably find them some matches. The question now is only which language will they start to push as a competitor to Swift, for compete they must.

Will it be Dart, a little more verbose than Swift, but modern, or perhaps Go, simple, elegant, but lacking in certain oft requested features (Generics / exceptions)

Personally, I vote Go but I am wrong most of the time, honestly, ask Nicky, she will tell you!

Let's see.....

When in doubt pile on the type information...

OMG, I just spent twenty minutes trying to figure out a compiler error. I wrote my own version of List.filter

let filter pred =
 let rec filter_acc acc = function
  head::tail when predicate head -> filter_acc head::acc tail
  | head :: tail -> filter_acc acc tail
  | [] -> List.rev acc
  in
 filter_acc [];;

The bold variable above is identified as the source of the error and here is the message

Error: This expression has type ('a -> 'b) list but is here used with type 'a

What? acc is a list of functions that take 'a and return 'b, no it is simply 'a list.

After spending way too much time pondering this problem I finally accepted that I am a static type luddite and determined that if the type inference system can't make head nor tail of my code, I should give it a hint and see if the error changes. So in the function below I specify that the acc parameter to filter_acc is a list of some type

let filter pred =
 let rec filter_acc (acc : 'a list) = function
  head::tail when predicate head -> filter_acc head::acc tail
  | head :: tail -> filter_acc acc tail
  | [] -> List.rev acc
  in
 filter_acc [];;

Sure enough the error now concerns head::acc and the error changes to

Error: This expression is not a function, it cannot be applied

Aha, the compiler thinks I am attempting to use acc as a function (acc tail), the precedence of the cons operator is obviously very low.

The following corrects the problem:

let filter pred =
 let rec filter_acc acc = function
  head::tail when predicate head -> filter_acc (head::acc) tail
  | head :: tail -> filter_acc acc tail
  | [] -> List.rev acc
  in
 filter_acc [];;


Bear with it, if you find yourself in this situation pile on the type information and let the compiler help you identify, however, esoterically, where the real error lies.

Fork it

Most of my friends will be able to tell you that I have an absolute fetish for functional programming languages.

But, I have traipsed from pillar to post trying to find a viable solution to the c based languages that continue to dominate the landscape.

Whilst every port I have visited has shown great promise, there is always something that queers the pitch, so to speak.

Haskell. Lazy is cool but yields unpredictable performance.

OCAML. Fantastic ML derivative, but the concurrency story is weak.

Erlang. Fantastic concurrency, and R13A makes the whole package more compelling, but the outright performance is ho hum.

Clojure. OMG a Lisp that makes sense!!!! The JVM may not be the perfect platform but Clojure makes more sense than CL or scheme, but, but, but the JVM!!!!!

Scala. Functional programming merged with OO, prima facie pretty compelling, but I am concerned about the unholy alliance of OO and FP, and of course, the JVM!!!!!

Likewise I have discounted Python and Ruby because of their weak concurrency model (GIL), although, that being said, the reality is that both of these languages thrive in the w3 world and the whole process / thread per request -- via apache et al -- is inherently parallel.

The question I would like to pose is......

Am I chasing something that is already available through fork / execve?

Let's chat about it.

And here we go again...

RIght mates. Yet another attempt at this blogging nonsense.

My previous effort was necessarily co-opted by circumstances out of my control, so I am going to start afresh here.

Hopefully I can use this blog to codify some of my thoughts around technology in general and programming languages specifically, and if that allows some of my muckas to chime in with their own thoughts, all the better.