On CLR

Found an interesting piece of information related to .NET GC.

This is about preserving content as there is a lot of link rot now. I will paste the content along with the source URL:

Hello everyone, I am the Lead Architect of the CLR/UIFX group  and the Chief Architect of the .NET Frameworks.  I was thinking about what I should put in the first entry of my blog… as one of the founders of the CLR I thought it would be interesting to give you some history of how CLR was born in my blog’s intro entry.

Before the CLR I was working on JVM. When Mike Toutonghi, Peter Kukol, Anders Hejlsberg, and I realized that the JVM would not give us the flexibility to innovate in the places we cared about – support for other languages, deep interop with COM and unmanaged code, extensive frameworks to expose MS technology – we decided to join force with the COM team and form a new group,  tentatively named COM 2.0.

We soon disagreed about object management, specifically about explicit management like COM (AddRef/Release) versus automatic management (Garbage Collection), we decided to form 2 groups: COM+ and CLR. This marked the birth of the CLR group.

Early on, we were joined by a meta data group who had been prototyping some meta data schema for the C++ compiler. Peter Kukol and the C++ group collaborated on the IL instruction set. I designed the architecture of the runtime and wrote the Garbage Collector (and yes the GC prototype was was written in Common Lisp first and I wrote a translator to convert it to C++).

Soon we had all the fundamental components of a runtime, some runtime helpers for the base classes (String and Object), and a new cool language: C#. We were in the business to build the full fledge CLR and the Framework.

So there you go, for those curious minds this is how CLR was started.

In the next blog entry I will be writing about server modeling. Also feel free to let me know if there are specific topics you want to see me write about.

And then another one from the same blog: https://web.archive.org/web/20140506034645/http://blogs.msdn.com/b/patrick_dussud/archive/2006/12/01/aggregated-response-to-comments.aspx

I am aggregating the responses to the comments about my first post:

About Common Lisp and Lisp in general:

I have worked on Lisp for many years, and I think it has strength that sets it apart from other dynamic languages. My favorite is the fact that you can extend the Lisp language to create your own special purpose language in a very natural way using macros. Lisp has a very simple syntax (prefix notation). As long as your extensions adhere to that syntax, it is possible to make them seamless. Arguably, CLOS is a very large extension to Common Lisp, even though you don’t need *any* compiler changes to do a pretty good job implementing it on top of regular Common Lisp.

Last year, I gave a talk at the International Lisp Conference about the need for Lisp to integrate with the CLR (and / or Java). See the following URL

http://www.international-lisp-conference.org/2005/speakers.html#patrick_dussud

About JVM limitations:

Well, the JVM has technical limitations that were hard for us to solve: the JVM is designed to execute type safe languages only and we wanted to executed unsafe C++ as well. Solving this would have required the support of the entire Java community and this didn’t make sense for the community at large.

Other limitation were contractual. We discovered that the compliance test suite didn’t allow us to extend the existing Java classes so it was hard for us to reflect the Windows platform with more fidelity.

We also discovered that it was very hard to negociate for a different / better Java to Native code interop layer. This was both a technical and political issue: the interop layer is heavily archicture specific – it is hard to make it universal aka Run anywhere-  and it is quite visible to programmers unlike an extension library on the side.

About the rationale for our design decisions:

First and foremost, we wanted to support safe execution of type safe languages . We designed a security model to separate trusted code from untrusted code and app domains to isolate code execution contexts from each other. We also wanted to be able to recompile an existing C++ application with an extra /CLR flag and run this application under the CLR. These high level goals lead us to where we are now. We briefly thought about a small GCed runtime for C++ but because C++ isn’t type safe, it wasn’t that interesting to us. Also you are severely limited in the ability to manage memory automatically for a language which can “hide” references in other datatypes or even by adding extra bits to the reference and such clever tricks.  

That lead to the person who has been maintaining the 35k LOC of gc.cpp: https://github.com/Maoni0 who works at Microsoft. An issue where someone was discussing splitting the file.

Advertisement

Functional Programming 1

I have started to learn multiple functional programming languages simultaneously. This might seem too much to handle (and maybe it is) but I am doing it to understand the way of thinking in different circles for the same paradigm.

Here is what I’m looking at and why:

  • Clojure: c42 alums are using this at gojek
  • Common Lisp: I have a book I can read offline
  • F#: It runs on .NET platform which is my day-job
  • Pure Script: Because Juspay is using this and I want to know more about presto.

Other languages that I want to look at:

  • ReasonML: Want to experience Reason React
  • Haskell: is the most “pure” form
  • Elm: ideas seem to be very

I don’t know what the long-term goals can be of this exercise though… for all I know, this is just a huge time sink without any tangible benefits.

No luck with my PR

Doesn’t seem like my PR related to addons-server will be merged anytime soon, which is disheartening. I was hoping that end of my story will be similar to the many I read about people starting their open source journey with Mozilla.

When browsing through their issues, I looked at the ones that weren’t assigned to anyone and something that I could contribute towards. The simpler ones seemed to have contrib-welcome tag and so I began working on those. Apparently, issues having this tag means that no one is particularly free to even describe the “fixed state”, so I the lowly contributor is on my own.

I’m not sure what to pick next, other issues are assigned/actively worked on by someone already. Should I move to a different project? Am I stopping too early? Maybe I should have picked a project I use everyday instead of looking something so different?

Some of the blogs I read said that I should either work on open source projects or personal projects, because you only have so much bandwidth.

I don’t know what to do next. I’ll keep looking for projects on github that I might be able to contribute towards.

No Silver Bullet

Came across this paper the other day:

No Silver Bullet: Essence and Accidents of Software Engineering (1987)

by Frederick P. Brooks

The author is an ACM fellow, was managing IBM System/360, a Super Computer OS and others in the ’70s and was also involved in US Defense project building an operating system.

While he was retiring, he was asked a question about why software projects are a lot harder to manage than hardware projects. This let to him publishing the Mythical Man Month and the essay/paper mentioned in this post.

About official sources for learning

Most, if not all, of what I say is in the context of software — be it programming language, product or website.

When I encounter a new piece of information, I always start with the “breadth” of the topic — what it means, how it’s useful, disadvantages and criticisms (usually this is from Wikipedia or the creator in case of a program).

Then I move to documentation provided from the vendor to look at idiomatic ways of doing things, their reasons for why they do it a certain way, etc.

So by the time I am done with this overview, I can start doing something with it: like run some sample. This is in contrast to how my peers learn: they first look for videos, and listen and practice is a lot later; besides, they don’t look at what criticisms or downsides people consider for it. This approach seems particularly problematic if the topic in question has evolved over the years and has a moderately long history as not all information in videos pertain to a certain version and may be out-of-date.

They seem to have different ways of learning that works for them — I like going from “breadth” to “depth”,and read instead of listen; they like to go the other way… Strange how our brains work.