درباره این اپیزود
In my role as Petri’s Community Magnate, I will be interviewing a variety of IT-savvy technology folks. Some of these will be Petri contributors; some will be tech-company employees; some will be IT pros. We will be tackling various subject areas in the form of 30-minute audio interviews. I will be asking the questions, the bulk of which we’re hoping will come from you, our Petri.com community of readers.
Readers can submit questions via Twitter, Instagram, Facebook and/or LinkedIn using the #AskMJF hashtag. Once the interviews are completed, we will post the audio and associated transcript in the forums for readers to digest at their leisure. (By the way, did you know MJFChats are now available in podcast form? Go here for MJF Chat on Spotify; here for Apple Podcasts on iTunes; and here for Google Play.)
Our latest MJFChat is all about .NET — its past, present and future. I recorded this episode on the day Microsoft celebrated the 20th (!) anniversary of .NET with Richard Campbell, a Microsoft Regional Director, MVP, entrepreneur and self-proclaimed “rabid podcaster.” Richard is working on a book about the history of .NET, so he has plenty to say about this topic. He also speculates about what .NET’s future might look like.
If you know someone you’d like to see interviewed on the MJFChat show, including yourself, just Tweet to me or drop me a line. (Let me know why you think this person would be an awesome guest and what topics you’d like to see covered.) We’ll take things from there…
Transcript:
Mary Jo Foley (00:00):
Hi, you’re listening to Petri.com’s MJF Chat Show. I am Mary Jo Foley, AKA your Petri.com community magnate, and I am here to interview tech industry experts about various topics that you, our readers and listeners want to know about. Today’s chat is about the past, present, and future of .NET. And the icing on the cake, we are recording this the very day that Microsoft is celebrating the 20th Anniversary of .NET. My special guest for this chat is Richard Campbell, an entrepreneur, Microsoft Regional Director, MVP, and self-proclaimed rabid podcaster, which I love. Hey, Richard, thank you so much for coming back and doing another MJF Chat
Richard Campbell (00:47):
Any time for you MJ, you know., And yeah, you know, I got too many shows. I’ve been doing a series now on understanding consumer neuroscience.
Mary Jo Foley (00:56):
Oh, wow.
Richard Campbell (00:57):
I’ve gotten involved with a company called Cloud Army that does technological-based consumer neuroscience. And so I wanted to learn and they needed the marketing assets and I have enough experience in marketing. It’s like, if I was a marketing person, I’m trying to understand how to use neuroscience in my job. Like how do we do that? And so that’s my role on the show, but I’m talking to like PhDs in neuroscience and things.
Mary Jo Foley (01:21):
Oh man, wow.
Richard Campbell (01:21):
It’s been really a lot of fun to just jump, and you know, me, I’m interested in everything.
Mary Jo Foley (01:25):
You are.
Richard Campbell (01:25):
So not hard for me to just dive in on a topic.
Mary Jo Foley (01:28):
No, it is not. But today’s awesome because whenever you’re talking about the history of .NET, I automatically think of you since you’re writing a book about the history of .NET. deal. Where is that book? Where is that book?
Richard Campbell (01:42):
So the funny part is like A, It’s Valentine’s Day, so Happy Valentine’s Day.
Mary Jo Foley (01:47):
Thanks, same to you.
Richard Campbell (01:47):
And B, yesterday, February 13th was the 20th anniversary of shipping .NET. And the whole way I got involved in the idea of writing a book started with the 15th anniversary of shipping .NET.
Mary Jo Foley (01:59):
Oh, wow.
Richard Campbell (02:00):
So back five years ago, I was asked by some folks at Microsoft to help out with an internal party. It was a party for the alumni, folks that had worked on it when it had shipped and so on. And so I got involved and I recorded a bunch of nuggets and little five minute pieces for Channel 9, the sort of happy birthday .NET and the experience for me as a guy who’s been in .NET since the very beginning and been involved in the podcast for almost as long. Cause it’s the 20th anniversary of .NET Rocks! too.
Mary Jo Foley (02:31):
Oh, wow.
Richard Campbell (02:32):
Was that often I could tell folks stories about their own product, they didn’t know. You know, the side effect of making 1700 and something episodes of .NET Rocks! is we’ve been here collecting the tales and sort of, you know, speaking it in the level of the gestalt about .NET for almost 20 years.
Richard Campbell (02:56):
And so back then, you know, a few folks were like, oh, I didn’t know that about my own product. When you’re talking to a guy like Mads Torgersen who is just immersed in everything C#, right? I mean, that’s the problem space he owns. He doesn’t spend a lot of time on the problems of how the CLR was built, or how that piece works, or the web pieces and things like that. He’s a language guy and many of these engineers that, I mean, they have to focus that way. I have the luxury of just telling the tale. I don’t have to invent the tech.
Mary Jo Foley (03:27):
Exactly.
Richard Campbell (03:27):
Tt=hose that invent the tech are way focused and they have thanked me for helping them tell their tale too.
Mary Jo Foley (03:33):
That’s nice, right.
Richard Campbell (03:33):
Like it works both ways that they’ve been busy building the thing and now they want to talk about it.
Mary Jo Foley (03:38):
Right.
Richard Campbell (03:38):
And so, you can help bring that story out.
Mary Jo Foley (03:41):
That’s true.
Richard Campbell (03:41):
But I came out of that experience thinking, wow, if we don’t start writing some of this stuff down, it’s gonna get lost.
Mary Jo Foley (03:48):
It will.
Richard Campbell (03:48):
And it took me a while to gear up to that, but I’ve been collecting interviews, private interviews ever since.
Mary Jo Foley (03:54):
That’s great.
Richard Campbell (03:55):
And trying to assemble a narrative that is coherent which is very much, I’m not gonna say, I don’t necessarily mean crime scene, but it’s got a forensic element to it. I have three versions of a meeting in 2005. They’re all different.
Mary Jo Foley (04:15):
Wow, wow.
Richard Campbell (04:16):
So you’re trying to figure out which, you know, which one is the, is the closest truth? My current angle is that often that meeting affects an outcome three years later. And so I found myself dismantling my storyline and assembling it backwards to try and actually make it consistent. It’s, I mean, writing tech books is a challenge, but writing history books is hard. History is tough.
Mary Jo Foley (04:41):
Sure. And you know, the other thing about .NET, I was talking with Paul Thurrott about this the other day, the way it was positioned to us when it was first announced. And then was kind of repositioned by Microsoft, a lot of that is something they don’t want out. And at the time definitely didn’t want out. They kept just telling us we didn’t understand certain things and the real truth was we did, but they were trying to change the way the story was told.
Richard Campbell (05:08):
Oh, sure.
Mary Jo Foley (05:08):
Right.
Richard Campbell (05:09):
Because, you gotta think about the other forces that were in play, right?
Mary Jo Foley (05:13):
Java.
Richard Campbell (05:14):
Well, and there was the battle over Java. Cause even before .NET emerged per se, you know, they’d already fallen off the rails with Java. The lawsuit that started with Java is in 1997.
Mary Jo Foley (05:30):
I remember it.
Richard Campbell (05:31):
And you know, so it was Brad Silverberg who pushed Microsoft to get involved in Java, that we can’t miss this boat. To the disagreement of a lot of the organization too, you know.
Mary Jo Foley (05:44):
Right.
Richard Campbell (05:45):
Microsoft doesn’t invent languages, they had their own implementations of BASIC. They had their own implementations of C++. They bought FoxPro arguably for certain elements of it like the Rushmore Engine and so forth. Like they had an array of languages, but all those other languages, if they didn’t outright buy them, they were languages developed by academia, right? They were part of the university side of computing science. Java was different.
Mary Jo Foley (06:08):
Right.
Richard Campbell (06:09):
You know, it was this enterprise language, it was actively developed and they had a mission around it that was very much about one language across many platforms. And they wanted it to be uniformed so that any Java developer could work on any implementation and it should work. Now that never was actually true.
Mary Jo Foley (06:28):
Right.
Richard Campbell (06:29):
You know, it was always more complicated than that. But you know, Microsoft is very, very good at building languages.
Mary Jo Foley (06:36):
They are.
Richard Campbell (06:36):
And very good at making great tooling, like that was always their strength. And, you know, Gates, lured Anders Hejlsberg away from Borland to work on Java tooling. Like that’s why he came to Microsoft.
Mary Jo Foley (06:50):
Right.
Richard Campbell (06:50):
And so by the time you get to ’97, Microsoft has an outstanding version of Java. I read a great quote from an IBM guy in that era that says, yeah, IBM makes their own version of Java, but we’re all developing using Microsoft’s implementation. And part of this of course was the utter dominance of Windows.
Mary Jo Foley (07:10):
Right.
Richard Campbell (07:10):
And Microsoft was good at making sure Java ran great on Windows and that’s ultimately how they ran afoul of Sun.
Mary Jo Foley (07:16):
It is, you know, and now we’re kind of in a weird full circle world because now Microsoft’s really putting a lot of resources into Java again, right?
Richard Campbell (07:26):
Yeah.
Mary Jo Foley (07:26):
And we actually had a listener ask a question on Twitter, @stackcook on Twitter said, so what is Microsoft gonna do about the onslaught of Java from Teams inside of Microsoft that are using it? And I was like, wow, I didn’t even think of that angle of the whole thing.
Richard Campbell (07:41):
Oh sure. I mean, and lots of C++ develops inside Microsoft, lots of Python develops inside Microsoft. I mean, the first thing is to recognize is that .NET was, .NET started out being about providing an enterprise development platform to sell Windows, but it’s not that anymore.
Mary Jo Foley (08:01):
No, right.
Richard Campbell (08:02):
Microsoft does not focus on selling Windows. It does sell Windows, but its focus is selling Azure, right? And selling cloud services, selling Compute. And so anything that needs Azure Compute is a good thing. You know, the turn towards cross platform open source was a double acknowledgment. It was an acknowledgment that a single platform product is never going to survive anymore in the modern world. But also that in the end, it all runs on cloud and cloud is how we make our living. And so unless we support everything, this cloud’s not gonna succeed either.
Mary Jo Foley (08:41):
Right.
Richard Campbell (08:41):
And again, Microsoft is very, very good at building developer tools. And so developer tools where you take anything you’re writing anywhere and run it in their cloud, that’s what they’re gonna build today.
Mary Jo Foley (08:53):
Right.
Richard Campbell (08:53):
And that, that helps us all. So I mean, but the question’s kind of odd. It’s not an either/or choice. Write In the language you like, I mean, when Azure was first shipped in 2009, it supported three development platforms. One was .NET, the other was Java, and the third was PHP.
Mary Jo Foley (09:19):
Oh, wow, I hadn’t thought about that, yep.
Richard Campbell (09:20):
I mean, that’s where it started. Java’s been in Azure since the beginning.
Mary Jo Foley (09:27):
Yeah.
Richard Campbell (09:28):
It’s just that for a while there, because of certain legal requirements, they, weren’t doing a whole lot of work on Java, but then they bought Minecraft and all of the customizations in Minecraft happen in Java. So obviously they need to work there as well. And in general, there’s been a swing either way. The question you have to ask is how much greenfield development’s happening in Java as much as how much greenfield development’s happening in .NET?
Mary Jo Foley (09:52):
Right.
Richard Campbell (09:53):
And that really gets down to what communities you’re living in or working in. But today, pick your language. It doesn’t matter. It’s not either/or choice like whatever one you want, they generally interoperate and they all run in the cloud.
Mary Jo Foley (10:10):
Do you think it really was more than just a PR move when Microsoft open sourced .NET Core? Like, was that a calculated move on their part or was it like, oh yeah, we should open source it because everybody’s open sourcing everything now.
Richard Campbell (10:24):
Yeah, you know what, it depends on who you ask. Because there’s definitely a different part, you know, we can’t think of Microsoft as a monolith, right?
Mary Jo Foley (10:30):
That’s true.
Richard Campbell (10:31):
It’s, it’s tens of thousands of people and all of them think all of the ways, but I think there was also an acknowledgment even at that time by important people that knew better, that if it isn’t open source, it’s fundamentally impaired, that those are table stakes to modern development practices. And so it has to be that way. And there is zero downside and many upsides, right?
Mary Jo Foley (10:57):
Right.
Richard Campbell (10:58):
Admittedly, this is not where Microsoft come from. I mean, Bill Gates largely invented the idea of charging for software. If you go back to the 70’s, when all of this starts, software was free, came with the hardware, right? In the personal computing world, there was lots of new machines coming up and each of them had their own things.
Richard Campbell (11:18):
And, Bill was smart enough to recognize the Osborne effect early on, this idea that as long as you’re making new hardware, people will keep waiting. And if you have to start over with all your coding on each hardware stack, nothing’s gonna get anywhere. He was trying to abstract from any given hardware stack, right from the outset by selling software. But people weren’t used to paying for software. I mean, he had had to largely, in a lot of ways, invent that market of software licensing, right. I hate to say this, but like, if you fast forward 200 years from now and say, what’s the history, you know, what did Bill Gates do? I mean, hopefully people remember maybe he cured malaria. I don’t know if it’s true and possibly broke the back of polio too, but really invented the end user license agreement.
Mary Jo Foley (12:05):
Hmm, that might be a plus or a minus, depending on how you look at that.
Richard Campbell (12:08):
It’s a very interesting point. What thee the EULA does is allows software to innovate without liability. Because what the EULA actually says is you don’t own your software.
Mary Jo Foley (12:18):
Right.
Richard Campbell (12:18):
You own a license to use it. And the limit of liability is the amount you paid for the software. So, Hey, you paid $300 for multi-plan, you know, and you use it to do the stress modeling calculations for a bridge. And there’s an error in the code that causes the bridge to collapse. Here’s your $300 back. I mean, that’s the game, but the side effect of that plan was that it allowed software to be developed very, very quickly. The downside of that is that it has kept software as kind of an infantile industry in some respects. Most industries like this, ultimately become engineering disciplines and we haven’t needed to because we haven’t been responsible for our own liability. You know, engineers, building bridges are responsible for those bridges falling down.
Mary Jo Foley (13:09):
True.
Richard Campbell (13:11):
Software developers largely, are not responsible for software failing. And that has a consequence. It’s allowed for very rapid innovation without a doubt, look where we are.
Mary Jo Foley (13:20):
Yes.
Richard Campbell (13:20):
But you know, the pursuit of reliability and software continues to be a challenge. And it’s getting better, but it’s still not the engineering discipline that I think it will ultimately become.
Mary Jo Foley (13:32):
Yeah, definitely. Okay, let’s switch gears a little and talk about the future. So, when we were preparing for this podcast, you sent me a note and you said, you know, as platforms get older, they typically get narrower. And so things, the key roles that they play may become the only roles. And you gave as an example, COBOL right. COBOL is now on mainframes, big batch processing tasks, but .NET’s not like that, right? And so I’m curious if you think as we go past the 20 year mark, things are gonna get narrower or what is gonna happen with .NET in terms of its focus?
Richard Campbell (14:14):
Yeah, and in some ways I think I misstated that too, because it’s not that the platform necessarily gets narrower, it’s that there’s more and more platforms.
Mary Jo Foley (14:21):
Sure.
Richard Campbell (14:21):
You know, COBOL was built for batch processing at a time where compute was very precious. These mainframes were expensive. And so you ran them, you wanted to offset the times and so forth. And so simpler languages, simpler practices, not a lot of UI, like it was just from a different era. And then along came the mini computer, and the microcomputer, and heaven knows the cell phone, and all of these other things that have changed things right? You know, one would argue when .NET was born in the early 2000’s where the desktop was still a dominant platform, it all made sense. Then the smartphone took off, right? Suddenly people’s primary compute devices are things that fit in their pocket.
Richard Campbell (15:01):
And that is not what .NET was built for at the time. Now, and, you know, .NET’s still not great on a phone, it’s still got its challenges. We have Xamarin and, you know, potential solutions around that. And there’s many others like building for phones is hard. It’s still hard. Doesn’t matter what platform you’re talking about.
Mary Jo Foley (15:22):
Yeah.
Richard Campbell (15:23):
But yeah, I mean, fundamentally what’s happened is that the overhaul, of. NET, the creation of .NET Core open source, cross platform, so forth was to try and to abstract it away from that so that it can be more tolerant. I would argue what’s interesting in the past 20 years, is the fact that we haven’t really changed all that much, even when you look at new languages, is they hit the abstraction right. The run time that abstracts you from hardware, so that as new hardware comes along, your pro just runs.
Richard Campbell (15:54):
You don’t, maybe you need to recompile, maybe you don’t. Right? I mean, just-in-time compilation, like we don’t even think about this, but in the 20 years that we’ve been building code in .NET, 64-bit came along for processors, ARM came along, remember Itanium.
Mary Jo Foley (16:10):
Yep.
Richard Campbell (16:11):
.NET ran on all of them. And for me, as a .NET developer, I didn’t have to do anything. Right, the CLR team did that for us. They dealt with that problem and that’s very powerful. And you see that same kind of abstractions on many other stacks, right. That’s the way Flutter works, you know, that’s, you know, it’s the way React Native works. Like, we seem to have the right level of extraction now for managing different bits of hardware. And that’s, what’s kept it going, right? The challenge of that craft is, as you add, new language features, you render obsolete old language features that you can’t take away cause you’ll break old code.
Mary Jo Foley (16:48):
Right.
Richard Campbell (16:48):
So how do you convince people to use the new features and not use the old ones?
Mary Jo Foley (16:54):
So how do you?
Richard Campbell (16:56):
So I put that question on guys like Mads Torgersen and other leaders, and the answer is tooling.
Mary Jo Foley (17:04):
Yeah, okay.
Richard Campbell (17:04):
That the tools should guide you to the best practices, to the modern way to approach it, to take advantage of the new language features. And I think you’re starting to see this. If you start looking at the coding environments, the squiggly lines that you suggest means syntax errors and things now are more elaborate than ever before, because they are hinting you towards better ways to code more reliable strategies. And I think part, you know, this is where you might see things like machine learning, coming to play, right? I don’t know if you’ve even looked at at GitHub Copilot
Mary Jo Foley (17:37):
Yeah, I’ve written a few things about it. It sounds pretty amazing.
Richard Campbell (17:41):
Well, and therein lies this interesting dynamic of, we have this huge data set that is all of this code that lives in GitHub. And we point a machine learning engine at it and say, well, what can you learn about how people are coding, what people are coding and so on. And then how can you help folks to code that way? So you can, one could speculate that we can get to a place where this copilot is prompting us into better practices. I mean, unfortunately, cause it’s Microsoft, you immediately think of Clippy, right?
Mary Jo Foley (18:19):
Right, yep.
Richard Campbell (18:20):
And you want Clippy to popup and says, it looks like you’re trying to do an MVVM pattern, yu want help with that? Which is funny, but also smart.
Mary Jo Foley (18:31):
Yeah.
Richard Campbell (18:32):
Because, when you start dealing with architectural patterns and software, which inevitably is emergent, like you can try and plan them on the whiteboard, but in a lot of respects, until you start writing the code and start seeing conflicts in your implementation and software, that patterns would help you clean up. It’s tough to get there. And so then the question is, are you implementing the pattern correctly? So if you could have software intelligent enough to recognize, this is probably the pattern we want, and if that’s true, here’s where your refactorings need to happen. Here’s how you organize this so that you don’t get into the pitfalls of this pattern, or get into problems with it. You know, a lot of folks when Copilot first showed up, said, well, this is the end of the developer, right?
Mary Jo Foley (19:17):
Right.
Richard Campbell (19:17):
Like I’m pretty sure that’s not true.
Mary Jo Foley (19:19):
Yeah.
Mary Jo Foley (19:20):
Cause software has no intentionality, in the end. You know, you make the mistake as a programmer if you think your job is to write code.
Mary Jo Foley (19:26):
Yeah, right.
Richard Campbell (19:28):
Job is to solve problems for folks. And often you code for that. And, if you’re experienced, you learn pretty quickly, as little code as possible, at least as little original code as possible. That’s why we have libraries and tools and the like, and so the fact that we might have smart tooling to help us write even less, even better code, that’s what the customer wants. That’s what a real, you know, a really experienced engineer does exactly as much innovation as needed and no more. You take what is known and reliable. You know, the job of a bridge is not to look beautiful, it’s to get cars across the river. It should also look beautiful too, and I think part of, you know, this, when we start applying to software engineering disciplines, and we think the same way about our software, it’s like first you gotta do the job. Then preferably do it with some grace and some sustainability that allows for the changes that are inevitably gonna come when more platforms arrive, right. Platforms continue to broaden. You know, you think about the next 20 years of .NET, it’s how is the platform going to broaden?
Mary Jo Foley (20:43):
So I was gonna ask you that, 20 years from now, we’re sitting here doing another podcast, who knows?
Richard Campbell (20:49):
I roll up in my wheelchair.
Mary Jo Foley (20:50):
Exactly, me too. Is .NET still there as it looks now, or, you know, just surrounded with smarter tooling or is there something else that evolves from .NET and is the new kinda way you do what .NET does?
Richard Campbell (21:06):
Yeah, part of this is, Hey, I have to guess what the new platforms are gonna look like.
Mary Jo Foley (21:09):
Right.
Richard Campbell (21:09):
So I look to places like Unity. I think generally speaking, if you’re a traditional .NET developer, you come from the enterprise space, you’re used to building winforms or web forms, apps, or you know, internal apps for your employer, that kind of thing. You may not have looked at how vast Unity is. Depending on which metrics you look at, it can be as much as like 60% of free to play games are built with Unity. And Unity has multiple implementations, right? It for a long time was Mono, right? The Miguel de Icaza’s implementation of .NET, which is part of .NET Standard and is continued to be maintained by Microsoft and runs across platforms and so on. But there is a Core CLR implementation for Unity as well. And so in that sense, there’s a massive ability to build really interesting software, still in C# across multiple platforms, even on the two video game consoles and the like. The most significant platform in our future that I can see at this point is the VR/AR space, maybe HoloLens, maybe not, I don’t know the answer to that. When it’s 2004 and you have a Motorola Razr in your hand, you can’t envision an iPhone.
Mary Jo Foley (22:34):
Right.
Richard Campbell (22:35):
And so, you know, here we are, in that context, looking at the array of different goggle devices, the Oculuses and the HoloLenses, and the Leaps and so forth. And I can’t pick a winner. I know from experience that it tends not to be the incumbents.
Mary Jo Foley (22:52):
Right.
Richard Campbell (22:54):
In a given space, but who knows, maybe innovators dilemma is over, probably not. But the AR device, augmented reality seems to be the thing that can supplant the smartphone. The smartphone is without the doubt, the most broadly used, most important compute device in the world. The majority of adult humans on this planet use it. We are all cyborgs. We all have a digital extension to ourselves. That’s the truth. You know, what has the smartphone really done, is it’s like, it’s spread that technology onto everyone. So if you’re gonna disrupt that, AR is the only thing that does everything the smartphone does and a bunch more. It needs ubiquitous, connectivity, it needs you know, a continuation of Moore’s law.
Richard Campbell (23:40):
Like there’s lots of things that have to happen. But from a development perspective, like for better or worse, Unity is very well positioned to jump on the AR bandwagon and architecturally .NET is well positioned to consume the net new hardware efficiently. They’re not the only one, like I would look at Fluttter and say, they’re well positioned too. What we don’t want is what happened with iPhone right? What happened with iPhone was kind of disastrous. Remember that when iPhone first shipped and Job’s said, if you’re gonna program for the iPhone, you’re gonna program in Safari, he was referencing HTML5 in 2008, when it wasn’t really baked. And of course what ultimately happened was smart people jail broke the phone and started to, you know, doing their own things with it. And that freaked Jobs out enough that he released his internal, the Apple Internal Development Tools, which is how we ended up with Cbjective-C and Cocoa and the like, and how rough those tools were, cause they were really internal tools.
Richard Campbell (24:41):
They weren’t meant for consumer developers. And all of the pain that that created. The problem is that typically hardware innovators are not necessarily great software developers tthat can build a great set of tools that will, you know, build a graceful development experience. So what we’re hoping, certainly what I think about is when that emergent AR device appears, will the sophisticated dev stacks be able to support it well enough that it’ll be part of that outbreak. I mean, I would argue that Hololens to me reminds me of the Blackberry in like 1998. Before, you know it’s hard to remember this, but getting email on your phone was a miracle then.
Mary Jo Foley (25:30):
It was.
Richard Campbell (25:30):
And it took a huge expensive infrastructure. It was only big companies that could pay for the Blackberry infrastructure that made that possible. And that’s kind of where HoloLens is right now, right? It’s a $3,500 device takes a lot of infrastructure, big organizations are doing it and finding somes success in that area. It’s not a consumer device.
Mary Jo Foley (25:49):
Yeah.
Richard Campbell (25:50):
I don’t know what the consumer device looks like right, and, where it’ll get to. When it does happen, what are the languages that are gonna be able to react? And certainly, you know, .NET’s done a good job of positioning on all of that. It is very interesting to think about what innovations would occur that would render .NET, unable to consume those new platforms. And this can get awfully esoteric. Like we can argue about sort of functional mindset, which is a very different way of programming than your imperative object oriented mindsets, but we’ve already got a functional language on the .NET stack.
Richard Campbell (26:29):
It’s F#. And while you don’t have to be strictly functional, you can abuse F#. You can also write awfully functional C# too. You know, under the hood the IL layer of .NET is very deeply steeped in object orientation. If you ever read the IL that is generated from F#, it’s pretty convoluted, but it’s fast enough people don’t mind. And, you know, functional is a way to write very terse code. So that doesn’t seem to be an interrupter. So we don’t have a lot of things in front of us right now.
Mary Jo Foley (27:06):
Right.
Richard Campbell (27:06):
That derail .NET from continuing for some time. But that’s also because we’re kind of blind, right?
Mary Jo Foley (27:12):
Right, I agree. Yeah. I feel like we can only imagine to a point, and as we’ve seen in the past 20 years, it’s not gonna look anything like what we thought 20 years ago, right?
Richard Campbell (27:24):
You know, it was easy in Chicago’s World Fair in the 30’s to talk about flying cars and video telephones and so forth. But the internet wasn’t in there.
Mary Jo Foley (27:35):
Right.
Richard Campbell (27:36):
You know, nobody predicted that, those are hard things to predict. And heck even when, when Tim Berners-Lee building the web, he was talking about scientific papers, having live footnotes. He wasn’t talking about Netflix. You know, that’s not what he was thinking about. It’s hard to envision how these new platforms come along. And we’re still really in the early days of cloud as a platform, right. As a utility, we still don’t really grasp what it means to have compute on demand and what that can ultimately shape itself into. We’re not there yet. All those forces are there, but, and we do have new languages, right. We do have Rust and Go and you know, fairly, fairly innovative ways to think about it. And there’s sure to be more to come along from there, it’s just a question of, are they gonna make enough difference?
Mary Jo Foley (28:30):
Yep.
Richard Campbell (28:30):
You know, the big, one of the advantages that .NET has of being 20 years old is they’ve been able to continue to improve the tools for 20 years. It used to be when the platform couldn’t cover all of the stacks that you needed it to cover you would have to start over, build a brand new platform and new set of tooling. And here they were able to redo the underlying framework without throwing away the tooling. And so the tooling has only gotten richer and broader. And that’s gonna be a pretty hard force to overcome.
Mary Jo Foley (29:02):
All right. Well, that’s the perfect ending for this chat I think. Thank you so much as always for a very enlightening and thought-provoking commentary.
Richard Campbell (29:16):
My pleasure MJ, thanks so much for having me back on.
Mary Jo Foley (29:19):
Yeah, of course. And for everyone else, who’s listening to this right now, or reading a transcript of this chat. I’ll be posting soon who my next guest tis going to be. And once you see that, if you want, you can submit questions directly on Twitter using the #MJFChat. In the meantime, if you know of anyone else or even yourself who might make a good guest for one of these chats, please do not hesitate to drop me a note. Thank you very much.
