CLI First with Kathleen Dollard
Summary
Kathleen Dollard returns to .NET Rocks after a four-year hiatus, sharing her experiences from her time at Microsoft and her recent health challenges. She discusses her passion for command-line interfaces (CLIs) and the philosophy of “CLI-first” design. Kathleen explains how CLIs serve as domain-specific languages (DSLs) that are not only efficient for developers but also crucial for scripting, automation, and interoperability with AI agents.
She delves into the history and current state of the .NET CLI and the System.CommandLine parser, which she helped develop. Kathleen highlights the challenges of maintaining backward compatibility while evolving CLI standards, and she introduces her new project, Dragon Fruit 2, which aims to simplify CLI creation with a better developer experience. She also touches on the POSIX standard, its age, and the need for modernization to better support AI and new use cases.
The conversation explores the advantages of CLI-first design, including better testing, clearer communication of intent through defaults, and easier integration into scripts and AI workflows. Kathleen and the hosts discuss security considerations, the role of CLIs in the age of AI, and how designing a CLI first can lead to more thoughtful API and library design. She also briefly mentions her upcoming talks on modern C# and source generators, indicating more topics for future discussions.
Recommendations
People
- Simon Cropp — A developer and advocate for the T-unit testing framework. He is mentioned as someone who loves T-unit and asked the community who was using it.
- Jason Bock — Author of the book ‘Metaprogramming in .NET.’ Kathleen references a comment from another guest, Shmuley Englard, praising the book and sharing insights about source generators.
- Chet Husk — The current lead for the .NET CLI and SDK team at Microsoft. Kathleen mentions his work on improving the CLI, such as adding interactive mode detection.
Standards
- Open CLI Standard — A standard mentioned by Kathleen, associated with Patrick Svensson, aimed at making CLIs more discoverable and usable by AI agents. It seeks to create a structured way for AI to understand and invoke CLI commands.
- POSIX Standard — The long-standing standard for command-line syntax (e.g.,
--forcevs-f). Kathleen discusses its strengths but argues it’s time to look at extensions and updates to better support modern use cases like AI and improved scripting.
Tools
- System.CommandLine — The official .NET library for parsing command-line arguments. Kathleen emphasizes that developers should never write their own parser and should use this well-tested, high-performance library instead.
- Dragon Fruit 2 — Kathleen’s own project on GitHub (KathleenDollard/DragonFruit2), a next-generation wrapper for System.CommandLine that aims to provide a much better developer experience for creating CLIs with subcommands and advanced features.
- Spectre.Console — A tool mentioned for creating beautiful console applications. Kathleen notes that modern tools like this allow for rich, formatted CLI output that wasn’t possible when the original POSIX standards were created.
Topic Timeline
- 00:01:16 — Introduction and Kathleen’s Recent Journey — Kathleen Dollard is introduced as a returning guest. She shares that she left Microsoft in May due to layoffs, which coincided with a cancer diagnosis. She expresses gratitude that both events happened on the same day, avoiding sequential shocks. Kathleen reports that her cancer treatment was successful and she is now cancer-free, regaining her energy and looking forward to new projects.
- 00:17:20 — Passion for CLIs and Domain-Specific Languages — Kathleen outlines her current interests: modern C# and command-line interfaces (CLIs). She describes CLIs as domain-specific languages (DSLs) that allow developers to express intent efficiently. She recounts her involvement with the .NET CLI and SDK team at Microsoft, emphasizing the importance of good CLI design for both human users and AI agents. She introduces the concept of the Open CLI standard for better AI interoperability.
- 00:24:46 — System.CommandLine and the Dragon Fruit Project — Kathleen discusses System.CommandLine, the parser library for .NET CLIs, which spent seven years in beta before release. She criticizes its developer experience and introduces her side project, Dragon Fruit 2 (on GitHub), which aims to provide a better UI wrapper around System.CommandLine. The goal is to simplify CLI creation using familiar class-based DTOs and to add features like better defaults, environment variable support, and JSON-script compatibility.
- 00:31:37 — The Case for CLI-First Design — Kathleen argues that most software should be designed “CLI-first.” She explains that a CLI provides a strong organizing force, making features, defaults, and intent explicit. It improves testing, prototyping, and stakeholder communication by focusing on functionality before UI aesthetics. CLIs also naturally limit application size and complexity, encouraging modularity over monolithic GUI applications.
- 00:39:41 — Modernizing CLI Standards for AI — The discussion turns to the aging POSIX standard for CLIs. Kathleen suggests it’s time to consider extensions to better support AI and modern tooling, such as structured help formats and prompting for missing values. She mentions the Open CLI initiative as a venue for these discussions. The key is to maintain backward compatibility while enabling new capabilities that make CLIs more accessible to AI agents and easier for humans to read in scripts.
- 00:50:49 — Future Talks and C# Resources — Kathleen shares her upcoming speaking engagements, including a talk at Techorama on writing sane Roslyn source generators. She mentions plans to revive her “Become a Better C# Programmer” workshop and to create content on modern C# and C# gotchas. She invites developers to look at her Dragon Fruit 2 project as a non-trivial example of a source generator.
Episode Info
- Podcast: .NET Rocks!
- Author: Carl Franklin and Richard Campbell
- Category: Technology Software How-To
- Published: 2026-03-05T04:00:00Z
- Duration: 00:56:00
References
- URL PocketCasts: https://pocketcasts.com/podcast/net-rocks/2b369ce0-0426-012e-f9a0-00163e1b201c/cli-first-with-kathleen-dollard/f56d4ad6-6b7e-4515-9225-871e7fe65590
- Episode UUID: f56d4ad6-6b7e-4515-9225-871e7fe65590
Podcast Info
- Name: .NET Rocks!
- Site: http://www.dotnetrocks.com
- UUID: 2b369ce0-0426-012e-f9a0-00163e1b201c
Transcript
[00:00:00] Psst, how’d you like to listen to .NET ROCKS with no ads?
[00:00:04] Easy, become a patron.
[00:00:06] For just $5 a month, you get access to a private RSS feed where all the shows have
[00:00:12] no ads.
[00:00:13] $20 a month will get you that and a special .NET ROCKS patron mug.
[00:00:18] Sign up now at patreon.dotnetrocks.com
[00:00:22] Hi this is Karl Franklin.
[00:00:24] And this is Richard Campbell.
[00:00:25] We’ve got two special shows coming up soon, episode 1999 and 2000.
[00:00:32] For episode 1999, we’re collecting people’s Y2K stories.
[00:00:36] What did you do to help the Y2K event not actually happen?
[00:00:40] And for episode 2000, we’re going to be sharing stories about how .NET shaped
[00:00:44] your career.
[00:00:46] We have a special page at .NETROCKS.COM slash VOXPOP where you can record messages
[00:00:51] for us that we can play on these special episodes.
[00:00:54] So tell us what you did for Y2K.
[00:00:57] And what .NET means to you.
[00:00:58] And of course how long you’ve been listening to .NETROCKS.
[00:01:01] So go to .NETROCKS.COM slash VOXPOP now and leave us a message before the
[00:01:06] thought evaporates like whiskey left in a glass overnight.
[00:01:09] Do it!
[00:01:16] Hey, and welcome back to .NETROCKS.
[00:01:24] I’m Karl Franklin.
[00:01:25] And I’m Richard Campbell.
[00:01:26] Kathleen Dollard is here with us.
[00:01:27] We’re going to be talking to her about, you know, what she’s up to lately and
[00:01:31] all that.
[00:01:32] But this is episode 1992.
[00:01:39] Maybe we should start with what happened that year.
[00:01:41] All right.
[00:01:42] Bunch of stuff.
[00:01:43] Bunch of stuff.
[00:01:44] It’s a busy year.
[00:01:45] Where do you want to start?
[00:01:46] Well, Rodney King, the LA riots.
[00:01:48] Very sad.
[00:01:51] Bill Clinton defeated George H.W. Bush.
[00:01:55] Cold War was declared over by the U.S.
[00:01:58] and Russia, South Africa.
[00:02:00] Soviet Union.
[00:02:00] Yep.
[00:02:01] Theory.
[00:02:01] Yep.
[00:02:02] Then before the Soviet Union, then Russia, right?
[00:02:05] Yeah.
[00:02:05] South Africa voted to end apartheid and the Bosnian War began, of course.
[00:02:11] Hurricane Andrew.
[00:02:13] Let’s see.
[00:02:15] Queen Elizabeth, dubbed 1992, her annus horribles, horrible year due to family
[00:02:21] scandals and a fire at Windsor Castle.
[00:02:24] So Robin Williams, one of his favorite movies I really like you did is Aladdin.
[00:02:29] So Aladdin came out that year too.
[00:02:31] Oh, yes.
[00:02:32] Aladdin came out.
[00:02:33] Yep.
[00:02:33] Some good movies.
[00:02:34] Don’t miss out the North American Free Trade Agreement.
[00:02:37] And NAFTA was signed that year.
[00:02:38] And so is the Maastricht Treaty, which is the beginning of the European
[00:02:42] Union.
[00:02:42] Wow.
[00:02:43] Oh, OK.
[00:02:43] Amazing.
[00:02:44] And while we’re on it, Richard, why don’t you tell us about tech, science,
[00:02:47] and space in 1992?
[00:02:50] It’s a crazy year for shuttles.
[00:02:52] This is the first year that Endeavour, the replacement for Challenger, flies.
[00:02:57] And so there are eight shuttle missions this year.
[00:03:00] Endeavour will fly twice.
[00:03:01] Once it is made in flight to do a reboost of a satellite, Intel Saturn 603.
[00:03:06] And again, for one of the three space, four space lab missions
[00:03:11] that happened that year.
[00:03:12] So lots of, you don’t realize this, but there was a bunch of different space
[00:03:17] labs.
[00:03:18] They were reconfigurable.
[00:03:19] And so Discovery, Atlantis, Endeavour, and Columbia all fly space lab missions.
[00:03:27] The rest are all satellite deploys.
[00:03:30] On the Russian side now, this is 1992, they do their first mission back to Mir
[00:03:36] with the breakup of the Soviet Union in July, TM-15.
[00:03:40] And one last space flight, and that is in September, the final flight of a Titan
[00:03:45] 3 rocket boosting the Mars Observer to Mars.
[00:03:51] Although it will not arrive.
[00:03:53] And I’ll wait until we next show to tell the story of Mars Observer,
[00:03:58] because the loss of Mars Observer changed the way NASA approached
[00:04:03] satellites going forward.
[00:04:05] Right.
[00:04:06] Yeah, they lost contact with it.
[00:04:07] They didn’t know what happened.
[00:04:09] About three days before it was supposed to do its orbital insertion,
[00:04:13] they were powering things up.
[00:04:14] It looks like there was a problem with the fuel system
[00:04:17] and the vehicle exploded, which is unfortunate,
[00:04:20] because it was a billion dollar mission.
[00:04:22] That’s why I was flying on a Titan 3, it was huge.
[00:04:25] And they took all the, this is where smaller, faster, cheaper comes
[00:04:29] from, Dan Goldin’s idea, where they take the spare instruments
[00:04:34] from Mars Observer, they spread it across four other satellites
[00:04:38] that will go to Mars, two of which will also fail.
[00:04:42] So at least some of the sensors will get to Mars successfully.
[00:04:45] But the building of these massive one-off exploratory satellites
[00:04:51] will never happen again.
[00:04:52] They’ll stay small after this.
[00:04:54] On the computing side, this is the year that DEC announces
[00:04:58] their Alpha chip, a 64-bit risk processor.
[00:05:02] It is one of the chips that will be supported by NT
[00:05:05] when that’s available.
[00:05:06] There will only be a MIT full of computers.
[00:05:08] A few different companies will build these eventually.
[00:05:11] As DEC disappears, the Alpha chip
[00:05:13] will be acquired by Compaq, who will eventually phase it out
[00:05:16] in favor of the Intel Itanium chip.
[00:05:20] That was wildly successful.
[00:05:22] Windows 3.1, right?
[00:05:24] Yeah, Windows 3.1 comes out that year,
[00:05:26] which is a great year for that.
[00:05:27] And also Visual Basic 2 and VB for DOS.
[00:05:32] I remember.
[00:05:34] It’s also the year that Microsoft
[00:05:35] produces the Microsoft Developers Network, MSDN.
[00:05:40] Yeah, I was working at Crescent Software
[00:05:42] and writing the Q&A column for then
[00:05:47] before Visual Basic Programmers Journal.
[00:05:49] I think it was called Basic Pro Magazine.
[00:05:51] And we got called into a meeting with the guys
[00:05:56] at Microsoft on the quick basic team and basic 7 PDS.
[00:06:01] And they were contemplating selling it to us.
[00:06:05] And they were like, what would you do with it?
[00:06:07] And we said, well, we’d just keep supporting it
[00:06:08] and blah, blah, blah.
[00:06:09] And then they said no and came out with VB DOS.
[00:06:13] Interesting.
[00:06:14] Thus, putting a nail in the coffin of basic 7 PDS,
[00:06:18] I think.
[00:06:19] Because there was no memory left over for your code.
[00:06:22] It was all filled with windowing stuff.
[00:06:24] Yeah, the overhead’s so large.
[00:06:28] Couple other hardware tidbits.
[00:06:29] A company called Sundisk, you now know them as Sandisk,
[00:06:33] manufactures the first solid state drive
[00:06:36] and SSD for IBM in sample quantities.
[00:06:40] Also, Intel introduces PCI, a peripheral component
[00:06:44] interconnect.
[00:06:44] So if you’re talking about PCs back in the day,
[00:06:47] the original PC and XT had the 8-bit PC bus.
[00:06:53] As the 286, 386, and 486s come out,
[00:06:55] they released the 16-bit ISA bus.
[00:06:59] They’ll later be a bus called ESA,
[00:07:01] although it was not particularly popular.
[00:07:03] This is also the year that another replacement bus
[00:07:05] is announced called the Visa local bus,
[00:07:08] but nobody does this.
[00:07:10] PCI rapidly becomes the popular standard.
[00:07:13] It will later be replaced by both AGP in the late 90s
[00:07:16] and then finally, what we use today, PCI Express.
[00:07:20] The first two words of toy boy, PCI and AGP.
[00:07:25] There you go.
[00:07:27] More operating systems.
[00:07:28] OS2, the IBM Malfoy system, the 32-bit edition is released.
[00:07:32] Also, Linux is released under the GNU,
[00:07:36] which is GNU is not Linux, GPL license.
[00:07:40] So that’s all the OSs, I think.
[00:07:44] IBM puts out the very first ThinkPad
[00:07:47] and from the very beginning, with the TrackPoint pointer.
[00:07:50] The little rubber looks like a pencil eraser nub
[00:07:53] in the middle of the keyboard from the very first version.
[00:07:56] And just so you know, it’s the first version.
[00:07:59] The display on this laptop is 10 inches and it’s a TFT LCD.
[00:08:05] I wanted one so bad, couldn’t afford one.
[00:08:07] They were, they were a big deal.
[00:08:09] Last piece of hardware
[00:08:10] and I want to pull a couple of software ones.
[00:08:13] Apple CEO, John Scully, announces the Newton.
[00:08:17] Oh yeah.
[00:08:18] Calling it a personal digital assistant, a PDA.
[00:08:22] It won’t actually start shipping till 1993
[00:08:24] and it’ll be dead by 1997,
[00:08:25] but you know, that’s the beginning of that.
[00:08:27] Well, you know, it wouldn’t have been bad,
[00:08:29] but it only came in one flavor, Fig.
[00:08:33] But you had to learn how their language
[00:08:35] for how to draw on it, right?
[00:08:36] Yeah, yeah.
[00:08:37] Couldn’t read regular handwriting.
[00:08:39] On the internet side of things,
[00:08:41] this is the year that the Joint Photographic
[00:08:43] Experts Group standardizes
[00:08:45] an image format we know as JPEG.
[00:08:48] Yeah.
[00:08:48] And a guy named Mark Cahill
[00:08:50] coins the term surfing the internet.
[00:08:53] Right.
[00:08:53] And two pieces of software, pass the language and stuff.
[00:08:57] The kid’s software releases Castle Wolfenstein.
[00:09:00] Oh yeah.
[00:09:01] And Adobe puts out a Photoshop 2.5,
[00:09:03] which is not that big of a deal,
[00:09:04] except it’s the first version released for Windows.
[00:09:07] Nice.
[00:09:08] That’s all I got.
[00:09:09] Well, let’s talk about the top 10 albums in 1992.
[00:09:11] I’ll make it quick.
[00:09:13] Sonic Youth’s Dirty album.
[00:09:16] Popular singles are 100% and Sugar Cane.
[00:09:20] Countdown to Extinction by Megadeth.
[00:09:24] The popular singles are Symphony of Destruction,
[00:09:27] Sweating Bullets.
[00:09:28] Mary J. Blige put out What’s the 411?
[00:09:32] Real Love, You Remind Me, Sweet Thing.
[00:09:35] The Bodyguard, Whitney Houston, I Will Always Love You,
[00:09:39] I Am Every Woman and Run To You.
[00:09:41] Who could forget Whitney?
[00:09:42] She was so good.
[00:09:43] She had an amazing year too.
[00:09:45] Yeah.
[00:09:47] Billy Ray Cyrus, Achey Breaky Heart.
[00:09:50] Lord.
[00:09:51] That’s the one I wanted you to not miss.
[00:09:52] If you hadn’t gotten that one,
[00:09:53] I was gonna jump in with that.
[00:09:54] Achey Breaky Heart was that year.
[00:09:56] Number six.
[00:09:58] I think that might’ve kicked off the line dancing craze.
[00:10:01] I’m not sure if it was going strong before that.
[00:10:04] The album, of course, is called Some Gave All.
[00:10:08] Pearl Jam.
[00:10:09] Wow, some great singles.
[00:10:11] Jeremy, Alive, Even Flow.
[00:10:15] Ten was the 1992 fifth most popular album of that year.
[00:10:22] U2’s Octong Baby.
[00:10:24] Huge.
[00:10:25] In 1992.
[00:10:28] One, Mysterious Ways, Even Better Than the Real Thing.
[00:10:33] Who’s Gonna Ride Your Wild Horses?
[00:10:36] Yeah, so good.
[00:10:39] R.E.M., Automatic for the People.
[00:10:41] Everybody Hurts, Man on the Moon Drive,
[00:10:44] The Sidewinder Sleeps Tonight.
[00:10:47] Amazing album.
[00:10:49] The Chronic by Dr. Dre.
[00:10:51] Absolutely a smash hit.
[00:10:53] This is number two.
[00:10:54] Nothing but a G-thang.
[00:10:56] Dre Day and Let Me Ride are the singles.
[00:10:59] And the number one album of 1992.
[00:11:03] Eric Clapton, Unplugged.
[00:11:05] Awesome.
[00:11:05] Tears in Heaven, Acoustic Layla.
[00:11:07] All those great songs.
[00:11:09] He just cleaned up in 1992.
[00:11:13] So anyway, that’s it for our reminiscing.
[00:11:16] I guess we should go on to Better Know Framework.
[00:11:19] Awesome.
[00:11:20] All right, man, what do you got?
[00:11:23] Oh, what’s T-unit?
[00:11:25] Well, I’ll tell you.
[00:11:26] It’s not Tuneit.
[00:11:28] Tuneit, I don’t know.
[00:11:32] Yeah, T-U-N-I-T.
[00:11:34] It’s a modern testing framework for .NET
[00:11:36] that uses source generated tests.
[00:11:39] Ooh.
[00:11:40] It’s parallel by default, parallel execution.
[00:11:43] It’s a modern testing framework for .NET
[00:11:47] that uses source generated tests.
[00:11:50] And it has native AOT support
[00:11:51] built on Microsoft testing platform.
[00:11:55] It’s faster than traditional reflection-based frameworks
[00:11:58] and gives you more control over how your tests run.
[00:12:01] And more importantly, our friend Simon Krop loves it.
[00:12:05] However, he asked us, by us,
[00:12:08] I mean the guys in the AppTunex Slack,
[00:12:11] who’s running T-unit?
[00:12:12] And the answer was, what’s T-unit?
[00:12:15] Nice, I think that was my line.
[00:12:18] Yeah, yeah.
[00:12:19] What’s that?
[00:12:21] So there you go.
[00:12:23] Know it, learn it, love it, we’ll…
[00:12:24] Awesome.
[00:12:25] Well, if it’s endorsed by Simon Krop,
[00:12:26] you should pay attention to it.
[00:12:27] Absolutely, yeah.
[00:12:28] So who’s talking to us today, Richard?
[00:12:30] Ground to Commonwealth Show 1988.
[00:12:32] Not that far back with our friend Jason Bach
[00:12:34] talking a little bit about .NET source generators.
[00:12:37] You can see a theme here.
[00:12:38] And our recent also guest, Shmuley Englard said,
[00:12:42] first, I need to share
[00:12:44] that I have met a programming .NET,
[00:12:46] that’s Jason’s book,
[00:12:47] and I love it so much,
[00:12:48] two important things I wanted to share.
[00:12:50] First, the source code generated by source generators
[00:12:53] is read-only, you cannot change them.
[00:12:56] And second, for me,
[00:12:57] one of the easy ways to know
[00:12:58] if I may want a source generator
[00:13:00] is if I was in C++,
[00:13:02] would I be writing a template or a macro?
[00:13:05] Interesting.
[00:13:06] I think you’d be asking Copilot to write it for you.
[00:13:09] I swear.
[00:13:09] Yeah, in C++, yeah.
[00:13:11] By sidestepping that whole process.
[00:13:15] Comments two weeks old, it’s already out of date.
[00:13:17] Yeah.
[00:13:18] Jason actually responded to Shmuley’s comment
[00:13:23] and thanked him for the nice comments
[00:13:26] and said, you’re right,
[00:13:27] source generator gen codes is read-only.
[00:13:29] Also, other source generators can’t react to code
[00:13:31] created by a source generator.
[00:13:33] So Shmuley, thank you so much for your comment.
[00:13:35] Copy and paste the code by is on its way to you.
[00:13:36] And if you’d like a copy and paste the code by,
[00:13:38] write a comment on the website at .NETrocks.com
[00:13:40] or on the Facebook,
[00:13:41] so you publish every show there.
[00:13:42] And if you comment there and not read it on the show,
[00:13:43] we’ll send you a copy and paste the code.
[00:13:45] Pretty sure Shmuley already has a copy of music to code by.
[00:13:48] I hope so, I would think.
[00:13:49] But if you don’t wanna leave a comment
[00:13:51] and you just wanna buy it,
[00:13:52] you can go to musictocodeby.net.
[00:13:54] There’s 22 tracks, approximately 25 minutes long,
[00:13:58] perfect for coding.
[00:14:01] And it helps you stay in that state of flow.
[00:14:06] And with that,
[00:14:08] let us bring back to the show Kathleen Dollard.
[00:14:11] She calls herself a .NET connoisseur.
[00:14:14] She’s certainly seen a lot of code
[00:14:16] as a long time teacher and consultant,
[00:14:19] as well as nearly eight years at Microsoft.
[00:14:21] Transitions are tough,
[00:14:23] but she’s ready for the next big adventure.
[00:14:25] And welcome back to the show, Kathleen.
[00:14:27] It’s been a while,
[00:14:28] but you have been a frequent guest here over the years.
[00:14:31] Yeah, I’m not sure how many I’ve done.
[00:14:32] It’s been a lot, but it has been a while.
[00:14:35] Maybe two years, it’s really been a little while.
[00:14:37] So I’m thrilled to be back, it’s great.
[00:14:39] Well, and you were on 1700,
[00:14:41] which was our collection of guests
[00:14:44] who’ve been on the most.
[00:14:45] Yeah, yeah, yeah, yeah.
[00:14:47] So if you’re in that,
[00:14:48] there’s a pretty clear sign you’ve done too many.
[00:14:50] But yeah, last one was four years ago
[00:14:52] when we were talking about C-sharp 11.
[00:14:53] Oh, four?
[00:14:54] Oh my, oh wow, that’s crazy, that’s crazy.
[00:15:00] So I did think,
[00:15:01] the fact that I’ve been a bit out of touch
[00:15:03] probably is partially because life got pretty intense
[00:15:07] the last two years that I was in Microsoft.
[00:15:10] We were running really short staffed.
[00:15:13] So what do you do when you’re short staffed?
[00:15:14] Do you let people laugh?
[00:15:15] So the PM team was short staffed
[00:15:21] and I think we didn’t,
[00:15:24] it was very hard to focus on what was important
[00:15:26] because there was so much going on.
[00:15:29] And then I left Microsoft in May with the layoffs,
[00:15:32] which broke my heart, it’s my dream job.
[00:15:36] And the funny thing is the same day,
[00:15:37] it’s not funny, but it was good.
[00:15:40] The same day, about two hours before they laid me off,
[00:15:43] I found out that I probably had cancer.
[00:15:45] And so it sounds like a terrible day.
[00:15:47] You go, oh my God, what a bad day, oh.
[00:15:49] But no, if you can imagine what would have happened
[00:15:51] if those things had happened two weeks apart
[00:15:53] and we had this life-changing event
[00:15:55] and you just got used to it.
[00:15:57] You just had your plan and then the other one dropped.
[00:16:00] That would have been horrible.
[00:16:02] I’m so grateful that I didn’t have a moment
[00:16:04] where I saw my life
[00:16:06] without these two things crashing on together.
[00:16:08] It was such a blessing because I didn’t have to worry about,
[00:16:11] oh, I’ve got new plans
[00:16:12] and now these new hard plans are destroyed.
[00:16:15] So the good news is that it was a very
[00:16:19] well-behaved cancer as cancer goes.
[00:16:22] And so I’m now, I go back for some checkups next week
[00:16:27] and I basically should be cancer-free at this point.
[00:16:31] So it was a tough, it was a tough six months.
[00:16:33] It was a tough six months, six to eight months,
[00:16:35] but I’ve got my energy back and I’m ready to go.
[00:16:39] I’m sure the stress of leaving Microsoft didn’t help.
[00:16:43] Well, yes and no.
[00:16:45] I worry a lot about how I would have coped
[00:16:49] if I’d had the stress of being at Microsoft
[00:16:51] during that time.
[00:16:52] So it was, I mean, I loved my job.
[00:16:55] I loved the people I worked with there.
[00:16:57] I don’t want to, I’m not saying anything bad about it,
[00:16:59] except that it is not an easy place.
[00:17:03] It’s not an easy place to work.
[00:17:06] It’s a hard place to work, very intense, very intense.
[00:17:08] Yeah, I loved it, but moving on to other things.
[00:17:13] And so yeah.
[00:17:14] Greener pastures.
[00:17:15] Yeah, I hope so, I think so.
[00:17:17] So what’s charging your batteries these days?
[00:17:20] Well, there’s what’s charging my batteries
[00:17:22] and what I’m kind of setting out towards doing.
[00:17:25] I do eventually have to do something else.
[00:17:26] I mean, it was good to take some time off
[00:17:29] and be able to focus on my health,
[00:17:30] but kind of done with that right now.
[00:17:32] So there’s kind of two big areas.
[00:17:34] One is C-Sharp with sort of a kind of a new vision
[00:17:39] for the way we talk about C-Sharp
[00:17:41] because it’s a new world out there.
[00:17:43] And the second is I’m very into CLIs
[00:17:44] and I don’t know which one you want to talk about first.
[00:17:47] So first of all, CLIs is the thing you type
[00:17:49] when you type in something like .NET Build.
[00:17:51] That’s what we’re talking about
[00:17:52] is what you type at the cursor.
[00:17:54] So I want to make sure that everybody’s on board
[00:17:56] with what we’re talking about.
[00:17:58] And it’s an amazing space.
[00:17:59] It’s just, I’ve been involved in it
[00:18:01] since I joined Microsoft which nine and a half years ago
[00:18:05] because I went in there just being a gooey person
[00:18:09] and they decided that, so because of that,
[00:18:11] I should run the .NET CLI and SDK
[00:18:13] because I’d have a good appreciation
[00:18:15] for people who didn’t have that
[00:18:17] as their first place of contact,
[00:18:19] which I think was great.
[00:18:20] So I learned a whole lot.
[00:18:22] Really fell in love with space
[00:18:23] because I’m a language geek from way, way, way, way back
[00:18:28] into at least 1992.
[00:18:31] And as a language geek, I love DSLs.
[00:18:34] I love the ability to express
[00:18:36] what you care about in a language.
[00:18:38] And there’s many places that’s not a good choice,
[00:18:41] but that’s what a CLI is.
[00:18:42] You get to build your own DSL
[00:18:44] and you get to do it within a framework.
[00:18:46] It’s like a sonnet instead of a free verse.
[00:18:49] All right, just for the one person
[00:18:50] who didn’t understand the acronym,
[00:18:52] CLI, command line interface, DSL, domain specific language.
[00:18:56] Thank you.
[00:18:57] And domain specific language just means
[00:18:58] that you’re making up the aspects of it.
[00:19:02] Now you generally don’t make up the syntax.
[00:19:04] It’s not only with a CLI
[00:19:05] where you don’t get full control of the syntax,
[00:19:07] but you have control of the semantics.
[00:19:09] So if we just look at the CLI
[00:19:11] that most people listening to this will know something about,
[00:19:14] well, there’s two, get and .NET
[00:19:16] would be the two most people listening to this
[00:19:18] will have probably used.
[00:19:19] And so when you say .NET space build,
[00:19:23] there’s code written that takes .NET
[00:19:26] to say that’s executable and build.
[00:19:28] That’s what we’re working on.
[00:19:30] And then takes all sorts of other things
[00:19:32] like you might have configuration
[00:19:33] and configuration would be dash dash config or dash C.
[00:19:39] And those rules are set out
[00:19:41] in something called the POSIX standard,
[00:19:42] which is ancient, absolutely ancient.
[00:19:45] And so one of the things
[00:19:46] that I didn’t have a chance to do
[00:19:48] while I was at Microsoft,
[00:19:49] it was on my plate, it was on somebody else’s plate.
[00:19:52] And now I’m like, you know, I might find time for that
[00:19:54] is to actually do some updating to that standard
[00:19:57] to say, you know, this is what we do.
[00:19:59] And like one of the areas that’s worth conversation
[00:20:02] is how we use abbreviations
[00:20:04] because dash F as in Frank
[00:20:08] is my favorite one to talk about
[00:20:10] because it regularly means two different things.
[00:20:13] And they’re just a teeny bit different.
[00:20:16] One is dash dash force
[00:20:18] and the other is dash dash format.
[00:20:21] So if you’re merrily thinking
[00:20:23] this should have a format and you go dash F
[00:20:26] to a command that you really didn’t wanna do
[00:20:28] a dash dash force to, there you go.
[00:20:30] So I think that there’s some things
[00:20:32] that we wanna talk about.
[00:20:34] There’s also a lot of orthogonal things.
[00:20:35] Help has not been updated
[00:20:36] since the initial POSIX standard in any real way.
[00:20:39] And now we have these spectacular tools
[00:20:41] like Spectre console,
[00:20:43] where we can really make beautiful things.
[00:20:45] And happily, I am still closely in touch
[00:20:48] with the .NET SDK and CLI team.
[00:20:50] And hopefully, I will now be on the outside
[00:20:53] pushing in my ideas and thoughts
[00:20:56] the same way I did before I joined Microsoft as an MVP.
[00:21:00] I was an MVP for 20 years.
[00:21:01] Joined Microsoft, got to work on the inside.
[00:21:04] Now I’m the outside setting up the conduits
[00:21:06] and the ways that I can work on the outside
[00:21:08] and make a difference.
[00:21:09] So that’s kind of what I’m doing.
[00:21:12] Well, the POSIX standards comes into play
[00:21:14] in the sense that POSIX says two dashes word
[00:21:17] rather than just like dash F
[00:21:19] would be dash dash force.
[00:21:21] Yes, right.
[00:21:22] So the POSIX standard is all these little details
[00:21:25] and it’s actually a good standard
[00:21:26] because it’s relatively consumable.
[00:21:29] And so if you have something that needs a name,
[00:21:32] then you can think of as a named parameter
[00:21:34] versus an unnamed parameter.
[00:21:36] So a named parameter in POSIX is gonna be dash dash
[00:21:39] and then the word,
[00:21:40] but it may be abbreviated if it’s a Boolean flag
[00:21:43] as just dash and then the letter.
[00:21:46] So I guess format’s a bad example.
[00:21:48] I’m gonna have to find another one
[00:21:50] because it would not be a Boolean.
[00:21:51] So you might think that abbreviation worked,
[00:21:53] but it generally wouldn’t
[00:21:54] because probably format wouldn’t be a Boolean.
[00:21:56] The only works with Boolean
[00:21:57] is one of the things I think is worth another look.
[00:22:00] I think I also come to the conclusion
[00:22:02] that we can do it in .NET.
[00:22:04] We don’t have to change the whole world.
[00:22:06] But the other thing up on that front is open CLI
[00:22:10] because the other really exciting thing,
[00:22:13] in addition to you can write this little language
[00:22:15] to help the people you work with,
[00:22:17] which people they’re writing CLIs to do regularly do it.
[00:22:20] They just may not think of it that way.
[00:22:22] The other thing is that you’re writing for AI
[00:22:25] and in today’s world,
[00:22:27] one of the really easy ways to set out
[00:22:30] what you offer as consumable without making it a service
[00:22:36] and without having to stand it up in that way.
[00:22:38] So it was just within your organization
[00:22:40] is just go out and find this executable
[00:22:42] on our local stores, wherever it is.
[00:22:46] Then you can write that and have it be available to AI
[00:22:50] via the CLI.
[00:22:51] And there’s a standard that’s called open CLI standard
[00:22:55] that Patrick Svensson is,
[00:22:56] I know about it through Patrick Svensson,
[00:22:58] but there may be some other,
[00:22:59] I know there’s other people that are involved in that,
[00:23:01] but that hopefully will be not just on it.
[00:23:03] That will hopefully be across the entire space.
[00:23:05] You know, it occurs to me that DSLs
[00:23:08] have kind of been replaced
[00:23:10] by these large language models, maybe.
[00:23:13] I don’t know.
[00:23:14] It would seem that you could use a large language model
[00:23:17] in the case of, you know,
[00:23:20] where you would have a DSL before possibly.
[00:23:23] I think that we are just so much
[00:23:27] at the top of the ski slope or avalanche
[00:23:31] or just at the beginning that we have no idea.
[00:23:35] I mean, I think we’re like,
[00:23:36] I don’t know what year we would pick.
[00:23:38] I don’t think it’d be 1992 in the internet world,
[00:23:42] but you know, we’re so much at that beginning.
[00:23:44] I don’t think we have any idea,
[00:23:46] but another possibility,
[00:23:49] the one I think is more likely,
[00:23:50] is that DSLs will feed AI
[00:23:52] so that AI is more likely to use a DSL
[00:23:56] on a thing that is done well
[00:23:58] and piece things that are done well together.
[00:24:00] I think that that is more likely
[00:24:02] to be the place we land
[00:24:03] when we realize that when I ask for something
[00:24:06] in chat in my browser,
[00:24:08] it doesn’t matter if it’s 100% correct,
[00:24:11] but when I run a program,
[00:24:13] especially one that does money or health
[00:24:15] or any one of a number of different things,
[00:24:17] it matters that it works well
[00:24:19] and it’s relatively fast.
[00:24:21] And so I think that we’re more likely
[00:24:23] to see a really good merging of these spaces,
[00:24:26] but I don’t know.
[00:24:26] You may be right.
[00:24:27] It could be that the code does get enough better
[00:24:32] that we don’t have those problems.
[00:24:34] It’s funny because I was just thinking,
[00:24:35] I don’t normally type .NET build.
[00:24:38] I run a script that has .NET build in it,
[00:24:41] and a bunch of other steps too,
[00:24:43] because repeatability.
[00:24:44] Yes, absolutely.
[00:24:46] And that’s one of the great things about CLIs
[00:24:48] is they’re so easily scriptable
[00:24:50] and there’s two projects,
[00:24:52] one’s out and one’s in process
[00:24:55] in terms of how you build them
[00:24:56] and they both really relate to scripts.
[00:24:58] And one of them is system command line,
[00:25:00] which is a parser in .NET land.
[00:25:03] Microsoft has it,
[00:25:04] which I worked on for seven years in beta.
[00:25:07] Tremendously painful experience
[00:25:08] because we did not have supportive management.
[00:25:11] And then finally with millions and millions of downloads
[00:25:14] that weren’t from Microsoft
[00:25:15] because they had a different store,
[00:25:17] they finally said,
[00:25:18] I guess we should do something and release this.
[00:25:20] So the right people got on board and it got released.
[00:25:23] So that’s great.
[00:25:26] Was that, that was .NET CLI?
[00:25:28] No, no, no, no.
[00:25:29] .NET CLI has been out forever.
[00:25:30] The parser that runs it,
[00:25:31] the parser it uses is called system command line.
[00:25:34] So if you want to write your own CLI,
[00:25:37] do not, do not, do not write your own parser.
[00:25:41] It’s tremendously difficult to write a good parser.
[00:25:43] Ask me how I know.
[00:25:45] Yeah, absolutely.
[00:25:45] It’s tremendously difficult.
[00:25:47] I know how much time and pain and love and wisdom
[00:25:50] went into system command line parser.
[00:25:52] Use it, or if you’d like Patrick Vincent’s console,
[00:25:55] better use it if you want to.
[00:25:57] There’s a couple out there that also are pretty good,
[00:25:59] but they have, there’s subtle standards
[00:26:02] within the .NET ecosystem
[00:26:04] that people actually probably will expect.
[00:26:06] So it really is a good idea to use that.
[00:26:09] That went into full release in November.
[00:26:11] So yay, everybody that was involved in that, three cheers.
[00:26:15] Some real heroes in that story
[00:26:18] because it was really fighting up a hill.
[00:26:21] So really big heroes.
[00:26:23] So it was always an internal library then,
[00:26:26] and it was never meant to be public.
[00:26:27] No, no, no, no, no, no.
[00:26:28] Just the opposite.
[00:26:29] It started as a open source public library
[00:26:33] that we did with the community.
[00:26:35] John and I did it.
[00:26:36] What happened is I did .NET tools.
[00:26:37] I was the PM for .NET tools.
[00:26:39] And when we released .NET tools,
[00:26:41] and I sat down and I wrote my little samples and stuff,
[00:26:44] I just wanted to cry
[00:26:45] because even for a completely crappy parser,
[00:26:48] over half my code was parsing code.
[00:26:51] It wasn’t anything to do with what I wanted to do.
[00:26:53] It was all just this crap parsing code
[00:26:55] that I did not want to write.
[00:26:57] And so I went to start asking around who can help.
[00:27:00] And John Sequero said, I might be interested in that.
[00:27:04] And I don’t know if he’s forgiven me yet,
[00:27:05] because it was a really painful seven years for all of us.
[00:27:09] And so anyway, we’ve got it out now.
[00:27:12] So there is a good parser out from Microsoft.
[00:27:15] It’s fast.
[00:27:16] It’s great.
[00:27:17] It’s wonderful.
[00:27:19] I don’t think it has a good UI though
[00:27:22] for the programmer.
[00:27:24] I actually think it’s terrible.
[00:27:25] So I was in Prague at update conference,
[00:27:30] and I stepped on stage.
[00:27:31] I was so excited.
[00:27:32] I said, oh, this is just nearly released.
[00:27:33] Everybody go take a look at this.
[00:27:35] And I’m showing examples of it.
[00:27:36] I’m going, we’re still writing a bunch of code
[00:27:39] that we have to learn about instead of just saying,
[00:27:41] just do it.
[00:27:42] So I’m working on a side project.
[00:27:44] And if anybody’s interested,
[00:27:45] it’s GitHub Kathleen Dollar Dragon Fruit Tube
[00:27:48] is the name of it.
[00:27:49] If you’re a system command line fan,
[00:27:51] you know what Dragon Fruit is.
[00:27:53] This is the next generation.
[00:27:55] It does sub commands and the things we’ve wanted
[00:27:58] in the Dragon Fruit, which is now gone.
[00:28:00] That’s not part of the released system command line.
[00:28:03] So that is going to be able to restate
[00:28:06] what we can do in CLIs.
[00:28:08] You talked about scripting.
[00:28:09] What is Dragon Fruit?
[00:28:10] It’s a wrapper for system command line
[00:28:12] that gives it a good UI.
[00:28:14] It lets you do a single create your entire CLI
[00:28:17] with classes that are familiar to you.
[00:28:19] And they’re basically DTOs.
[00:28:21] It wraps system command line and a DTO
[00:28:24] that that’s a data transfer object.
[00:28:26] It’s a simple little object.
[00:28:29] So it just marries those two together
[00:28:31] and lets you write your CLI very, very easily.
[00:28:33] So that’s the main goal,
[00:28:35] but it also will allow you to extend it
[00:28:38] because it’s open and we’ve got lots of things
[00:28:39] in there like better defaults.
[00:28:41] And you were talking about scripting, Richard,
[00:28:44] which if you know what you’re talking,
[00:28:47] if you know those commands, you already know them,
[00:28:49] then it’s very easy to read a script.
[00:28:51] If you don’t know those commands,
[00:28:53] it’s very hard to read a script
[00:28:55] because there’s things like,
[00:28:57] I talked about named and unnamed arguments.
[00:28:59] There’s a huge use of unnamed arguments within CLIs.
[00:29:04] And that’s a good thing if you’re typing, less to type.
[00:29:07] It’s a very bad thing if you’re reading
[00:29:09] because you see a word and you don’t know
[00:29:12] what that word is.
[00:29:13] And so let’s just say that you have a project
[00:29:17] in your system that is like, I don’t know.
[00:29:20] It’s, I don’t know, it’s like a run, okay?
[00:29:24] And that’s just the name of a project you’ve got.
[00:29:27] Well, if you see .NET build run,
[00:29:32] you don’t know what’s going on there.
[00:29:34] And you, because you can state a project
[00:29:36] after .NET build.
[00:29:37] So it’s difficult to use them.
[00:29:40] I think it’d be much easier for humans
[00:29:42] and definitely easier for AI
[00:29:44] if you could read a script that was written in JSON.
[00:29:47] And so that’s one of the things that this,
[00:29:49] that’s the kind of thing we can enable,
[00:29:51] prompting people have asked for a lot,
[00:29:53] being able to pull defaults from environment variables,
[00:29:56] all of those things are in the,
[00:29:58] they’re either in the system
[00:29:59] or they’re already designed into this wrapper.
[00:30:02] So that’s what I’m coding.
[00:30:03] It’s certainly a habit I have in writing scripts.
[00:30:06] And that’s as much PowerShell as anything .NET related
[00:30:09] to always use the double dash long names.
[00:30:12] Yeah, it’s a huge help.
[00:30:13] Just so, because it’s a pain to do once,
[00:30:15] but it’s in a script, you’re never gonna type it again.
[00:30:17] But when you go to read it, holy man.
[00:30:20] Yeah, I also suspect that you’re doing
[00:30:24] a great deal of good for any AI usage
[00:30:26] that that script would ever have.
[00:30:28] Yeah, I imagine.
[00:30:29] Either evaluation or to use it,
[00:30:31] to find out what it’s doing, to use it.
[00:30:33] For example, you might look at a bunch of scripts
[00:30:36] to say, what are the configuration files?
[00:30:39] So for that kind of work,
[00:30:40] I think that you’re way far ahead
[00:30:42] if you’re using the dash dash config instead of dash C.
[00:30:46] Even though in theory, the AI could work it back.
[00:30:49] It also-
[00:30:50] Should be able to, you’d think.
[00:30:51] It can.
[00:30:52] It’s just one less step.
[00:30:54] Right now, today, we don’t yet have that open CLI out,
[00:30:57] so we don’t have a guaranteed way
[00:30:59] for it to get to the actual intent
[00:31:02] of that particular domain-specific language
[00:31:04] and what does dash C mean for this particular command.
[00:31:08] And so because we don’t yet have a solid pipeline there,
[00:31:12] I actually think you’ll get better results
[00:31:14] as well as being easier to read when AI is involved.
[00:31:17] That’s interesting.
[00:31:18] Okay, why don’t we take a break?
[00:31:20] I got some questions after that.
[00:31:21] Sounds good.
[00:31:24] And we’re back.
[00:31:26] It’s .NET ROCKS, I’m Richard Campbell.
[00:31:27] That’s Karl Franklin.
[00:31:29] Hey-o.
[00:31:29] Hanging with our friend Kathleen Dollard
[00:31:31] after entirely too long.
[00:31:34] And just digging in on,
[00:31:37] the whole wave of CLI came from the open source side.
[00:31:41] And to me, it always was about appealing
[00:31:44] to non-IDE developers.
[00:31:48] Especially the younger generation of web developers
[00:31:50] who never went into Visual Studio
[00:31:52] that were used to rolling their own.
[00:31:53] And here was a way for them to build in .NET
[00:31:55] that they’re familiar with.
[00:31:57] I think that’s true.
[00:31:58] But I also think that it’s also better
[00:32:01] for certain things.
[00:32:02] So if you look at, we’ll use the .NET CLI again,
[00:32:05] but Git is equally true in Git.
[00:32:07] It’s not as structured quite as well as .NET CLI,
[00:32:09] I think.
[00:32:11] So the .NET CLI is huge.
[00:32:13] It’s actually quite large.
[00:32:14] There’s, I don’t know,
[00:32:15] 150 different options on different commands
[00:32:19] all stuffed in there.
[00:32:20] And that maybe doesn’t include NuGet
[00:32:22] and .NET Nu has an entire open system behind it
[00:32:25] of all the templates.
[00:32:26] It’s huge.
[00:32:27] It’s absolutely huge.
[00:32:28] So if you would just take a second
[00:32:31] and think about what the UI would look like,
[00:32:32] if it was a GUI,
[00:32:33] it’s horrendous.
[00:32:34] It’s a GUI you would take
[00:32:35] to do all those options.
[00:32:36] It’s horrible.
[00:32:36] So it was a very telling thing that happened around,
[00:32:39] I don’t know if it was PowerShell,
[00:32:41] I’m guessing it was,
[00:32:42] but it might have predated PowerShell.
[00:32:44] Where some of the work for IT professionals,
[00:32:47] the people back when we had IT pro folks,
[00:32:51] they had started,
[00:32:52] they went to GUIs
[00:32:53] and then they started having the real command line
[00:32:55] that would be the same thing
[00:32:57] at the bottom of the screens in many of the tools
[00:32:59] because yeah, you really needed that,
[00:33:01] both the build scripts.
[00:33:02] Very important.
[00:33:03] But also because there comes a point
[00:33:05] that just trying to assess the information
[00:33:08] that’s coming at you.
[00:33:09] And there’s this very small thing
[00:33:12] that CLIs do really well
[00:33:14] that is not obviously important stuff.
[00:33:17] And that is defaults.
[00:33:18] So if you look at that .NET build command
[00:33:20] that’s inside your script
[00:33:22] and you do or do not see a config,
[00:33:24] then that’s important information.
[00:33:26] Okay, so that’s very easy.
[00:33:28] And so a config you’re gonna probably have.
[00:33:30] Okay, that’s most likely you’re gonna have it.
[00:33:34] But there’s a whole lot of other things there
[00:33:35] like what your runtime is
[00:33:36] or what actually what the projects are.
[00:33:40] Are you just gonna build into this directory
[00:33:42] and move to the directory
[00:33:43] or are you going to state what the project is?
[00:33:45] There’s just a ton of things there
[00:33:46] that either are present or absent.
[00:33:48] But when you look at a GUI,
[00:33:50] you don’t have that ability to say,
[00:33:52] these are the things that are special
[00:33:54] about this particular case.
[00:33:56] And that’s what a default is.
[00:33:57] It’s what is special about this particular case.
[00:34:00] And nobody’s ever really built GUIs that say,
[00:34:04] the bright green stuff
[00:34:05] is all the stuff that’s not default.
[00:34:08] I’ve never seen that.
[00:34:09] And in fact, in a GUI,
[00:34:10] you generally can’t tell the difference
[00:34:11] because if you have a zero that’s a default
[00:34:13] versus a zero somebody entered,
[00:34:14] it looks just the same.
[00:34:17] Exactly the same.
[00:34:18] That’s a great insight.
[00:34:19] The neat thing about parameters
[00:34:20] is they’re all intentional.
[00:34:21] You wouldn’t put them if they weren’t.
[00:34:23] Optional.
[00:34:24] Any place you’re using optional parameters,
[00:34:25] that’s absolutely true.
[00:34:26] And in CLIs,
[00:34:28] you only put the things that you need to put.
[00:34:29] I don’t know anybody who just says,
[00:34:31] oh, for fun,
[00:34:32] I’m gonna go ahead and add a few extra things
[00:34:34] when they’re typing in to use a CLI.
[00:34:36] That’s a mean person.
[00:34:37] You don’t like that person.
[00:34:38] Don’t do that.
[00:34:39] Only put in parameters that matter.
[00:34:40] Especially if they’re doing scripts.
[00:34:41] No, you don’t, you don’t, you don’t.
[00:34:44] It’s a great,
[00:34:44] the other obvious one is
[00:34:46] it’s really hard to keep
[00:34:47] multiple GUIs across multiple people
[00:34:48] all in sync for configuration
[00:34:50] where, hey,
[00:34:52] a batch file sitting in a folder
[00:34:53] that everybody can access
[00:34:54] that is the only way to build,
[00:34:57] then everybody literally runs the same piece of code.
[00:35:01] And it fits in so well
[00:35:02] and was such a good driver for the SDK design
[00:35:05] and the overall design of all of it.
[00:35:07] Like, when they went to do
[00:35:10] the file-based applications,
[00:35:14] it’s like, okay, we know what to do.
[00:35:16] We don’t have to sit down and design anything.
[00:35:18] So we know that we want to say .NET build,
[00:35:20] blah, blah, .CS, okay?
[00:35:22] That’s what it’s gotta be.
[00:35:23] And now, how do we make that work?
[00:35:25] And so it was a huge, huge organizing
[00:35:28] and driving factor.
[00:35:29] Now we had some mistakes that came in,
[00:35:31] actually pre-me,
[00:35:32] but that’s okay.
[00:35:33] Like, we used to be able,
[00:35:35] used to have to say .NET add,
[00:35:37] I think it was add project and package add.
[00:35:40] So, but there were two,
[00:35:41] almost the same thing that we just switched.
[00:35:44] And that’s now removed.
[00:35:45] So now the noun-verb completely won.
[00:35:49] Everybody’s doing CLIs.
[00:35:50] Do noun-verb.
[00:35:52] Reach out to me if you need to understand
[00:35:54] how to do obsolescence in the CLI
[00:35:55] because it is a tricky thing to do,
[00:35:57] but you can do it well.
[00:35:59] It does bring up the question,
[00:36:01] now that you’ve talked about system command line
[00:36:03] and so forth and this tooling,
[00:36:04] who should be building CLIs?
[00:36:06] Like, I get that you should build CLIs,
[00:36:08] and you think like this
[00:36:10] and you’re building tools all the time you use,
[00:36:12] but who should be making a CLI?
[00:36:15] I can give you one right now.
[00:36:17] Just people who are using AI agents to do things
[00:36:22] that you typically have to build a CLI around, right?
[00:36:25] GitHub Copilot is a perfect example.
[00:36:28] So I think that there’s a bunch of answers.
[00:36:30] One is, who’s your audience?
[00:36:31] So if your audience wants GUIs,
[00:36:33] your audience wants GUIs.
[00:36:34] If your audience wants,
[00:36:36] the people are gonna use your app,
[00:36:37] want a command line app,
[00:36:38] they want a command line app.
[00:36:40] I’m of the opinion that almost everything
[00:36:44] should be designed CLI first,
[00:36:45] and then GUIs second,
[00:36:46] because in that way,
[00:36:48] you have the organizing force of the CLI,
[00:36:50] which, I mean, like I said,
[00:36:51] you just, it was so important in the .NET SDK.
[00:36:56] Oh, it’s a nightmare.
[00:36:57] It was, we made it better
[00:36:59] when we threw out the old .NET new
[00:37:00] and got the new .NET new,
[00:37:01] and there’s some things,
[00:37:02] NuGet’s relationship, you know,
[00:37:05] handing off to NuGet got better.
[00:37:06] This bunch of stuff got better over the last eight years.
[00:37:10] Somebody else runs it now.
[00:37:10] Chet Husk is the person who does that,
[00:37:12] but the part of it,
[00:37:17] the first answer is, what do people want?
[00:37:20] The second answer is, unless you have a really,
[00:37:23] I know this needs to be a GUI in this way,
[00:37:25] I want to design the GUI first,
[00:37:26] unless you know you want to design GUI first,
[00:37:29] design CLI first,
[00:37:30] it helps your testing,
[00:37:31] it helps your prototyping,
[00:37:33] it helps you communicate with your stakeholders
[00:37:36] without worrying about whether the button is blue.
[00:37:38] There’s just a ton of things you gain
[00:37:40] from being CLI first in your overall app design.
[00:37:43] It also keeps your apps from being too big
[00:37:45] because most of us look at something like,
[00:37:49] we’ll use get in .NET.
[00:37:50] They’re about as big as you can get.
[00:37:52] Azure CLI is actually not a single CLI.
[00:37:54] It’s a breaking off point
[00:37:56] into a whole bunch of little CLIs.
[00:37:58] It’s a prefix.
[00:37:59] It’s, you know, you can only get so big
[00:38:01] and it kind of keeps you at that size.
[00:38:03] Right, and that granularity is super useful too.
[00:38:06] Yeah, it’s like, should we break this up now?
[00:38:09] Becomes a good question for a good reason
[00:38:11] instead of a GUI app,
[00:38:14] which is just going to keep growing like a big amoeba
[00:38:16] until it’s taken over your entire company
[00:38:18] if it’s a medium-sized company.
[00:38:20] And that’s never good
[00:38:21] because then your ability to change
[00:38:22] to the next great thing drops near zero.
[00:38:25] Right, now that makes a lot of sense.
[00:38:27] Yeah, yeah.
[00:38:28] So, I mean, I hate,
[00:38:31] I really wanted to push on this idea
[00:38:32] that CLIs are all about AI,
[00:38:34] that there’s a bunch of reasons
[00:38:36] you were going out to CLIs anyway,
[00:38:37] going way back to the DevOps movement and so forth.
[00:38:40] But now it really opens the door to these new tools
[00:38:45] and the way they want to work as well.
[00:38:47] Yeah, it really is.
[00:38:48] And that’s why things like open CLI,
[00:38:50] looking at maybe some more expressiveness,
[00:38:52] looking at not being afraid to change,
[00:38:55] I’m no longer afraid to change the POSIX standard.
[00:38:56] I will not do it on my own.
[00:38:58] But I think that as a community, as an ecosystem,
[00:39:01] we need to take a look and say,
[00:39:02] can we either solidify some things other than dash H?
[00:39:08] Or can we, what can we do here to find some space to grow?
[00:39:13] Alternate help is a really obvious one.
[00:39:17] And prompting, prompting for acquired values.
[00:39:20] Being part of your parse system,
[00:39:24] not something you have to write
[00:39:25] for every application yourself if you want it.
[00:39:27] Had it be just a configuration switch.
[00:39:30] So, yeah.
[00:39:30] Yeah, it’s interesting to think
[00:39:33] because it is such an old standard
[00:39:34] that maybe needs to be modernized
[00:39:36] because of these new tools
[00:39:38] so that we have fewer problems going forward.
[00:39:41] Yeah.
[00:39:42] And I think everything that’s there will stay forever.
[00:39:45] I don’t think anyone’s gonna literally change it.
[00:39:47] Right.
[00:39:49] I said I’m not afraid to change it,
[00:39:51] but I really mean I’m not afraid
[00:39:52] to talk about extending it
[00:39:54] to see whether there’s buy-in
[00:39:55] on some of the things that we could do
[00:39:58] if we extended it.
[00:40:00] As simple as if we’re going to have help
[00:40:03] be in a more structured format
[00:40:05] to make it easier for AI,
[00:40:07] easier for some other things.
[00:40:08] Oh my gosh, can we all use the same format?
[00:40:10] Yeah.
[00:40:11] That’s what OpenCLI is ultimately about.
[00:40:14] You know, it’s got lots of things going on with it,
[00:40:16] but that is, you know,
[00:40:17] we need to use the same structure there.
[00:40:19] You mentioned obsoleteing a few minutes ago.
[00:40:22] Yeah.
[00:40:23] Is that the same as deprecating?
[00:40:24] Like, well, we don’t use that anymore,
[00:40:26] and now we use this?
[00:40:28] Pretty much, yes.
[00:40:29] That is really the answer,
[00:40:30] because unless something becomes strictly dangerous,
[00:40:35] strictly, you really need not to use this.
[00:40:38] Unless that happens, you can never remove anything
[00:40:41] because you’re going to break the scripts
[00:40:42] Richard was talking about.
[00:40:43] That all these people, you just think about,
[00:40:47] now the .NET scripts, of course,
[00:40:48] that’s massively in use.
[00:40:49] There’s absolutely cannot remove any feature ever,
[00:40:53] which is why it was so hard
[00:40:55] to get this verb noun thing fixed,
[00:40:57] because so many people said
[00:40:59] we can’t have two ways to do something,
[00:41:01] and we’re like, well, we’ll never fix it then,
[00:41:03] so can we please have two ways to do something?
[00:41:05] And literally, it’s taking what is the old way to do it
[00:41:09] that now is obsolete and just hiding it.
[00:41:12] That’s number one, just don’t put it in help.
[00:41:14] That’s step number one.
[00:41:16] And then this next step, which the .NET CLI,
[00:41:20] I think many CLIs are ready for,
[00:41:22] is to have a warning, is to have the replacement,
[00:41:24] and that is just, so I think you may see that
[00:41:26] within the .NET CLI in the mid future.
[00:41:29] I’m not sure this year, but soon,
[00:41:31] I think that’s gonna be there.
[00:41:33] I’m not sure if they’re working on it right now or not.
[00:41:35] What do you think about security around CLIs?
[00:41:38] Do we need to have a login or some tiers of authority
[00:41:44] for different commands in CLIs?
[00:41:47] It’s not my space.
[00:41:49] Right now, the answer is that the person you are,
[00:41:54] the framework that you’re in,
[00:41:55] the things seem to be working,
[00:41:57] but as AI comes in, will it?
[00:41:59] I don’t know.
[00:42:00] I don’t know the answer to that.
[00:42:01] It’s currently, the CLI runs in the context of the caller.
[00:42:05] Exactly.
[00:42:06] And so, this is where, if you live in Linux land,
[00:42:08] you would pseudo before running a CLI
[00:42:10] to promote your rights,
[00:42:13] and then the CLI runs in a higher level of knowledge.
[00:42:17] But hopefully in a very thoughtful way
[00:42:19] and only pseudo when you actually need to
[00:42:21] because it’s holding you safe.
[00:42:24] And otherwise, we may wind up with some wrapper,
[00:42:27] basically little terminal wrappers or repels
[00:42:30] that can hold more security
[00:42:32] for certain things that need it.
[00:42:33] That’s another way, and that’s another place
[00:42:34] that standards would be really important and valuable.
[00:42:36] Right, that you could be a parameter
[00:42:38] that carries a token, that kind of thing.
[00:42:40] Right.
[00:42:41] Or an approval question or something.
[00:42:44] So these are the kinds of things
[00:42:46] that we kind of got stuck in the standard
[00:42:48] and said, well, we’re not gonna think
[00:42:49] about these new things.
[00:42:50] We’re not gonna think about ways to change.
[00:42:52] And there’s a lot of answers to that question,
[00:42:54] including environment variables
[00:42:56] and having keys that have a short lifetime.
[00:43:00] There’s a ton of different things that could be done.
[00:43:03] And what’s the best thing?
[00:43:04] I am certainly not the person to make a guess
[00:43:06] as to what’s the best answer
[00:43:08] to have the most security with the least impact.
[00:43:11] And there might be more than one answer.
[00:43:12] I’m sure I do not want the CLI
[00:43:15] to generate a prompt for a password.
[00:43:17] That’s what I’m sure of.
[00:43:19] Yeah.
[00:43:20] The same way invoking an SSH call
[00:43:22] or a bash call might have a security prompt in it.
[00:43:25] Well, no.
[00:43:26] CLI should not behave like that.
[00:43:28] That is bad.
[00:43:29] Yeah, yeah.
[00:43:29] And thank you, because I do not yet,
[00:43:32] in this project, this Dragon Fruit 2,
[00:43:34] I do not yet have a special password type
[00:43:36] to ensure that it’s never prompted.
[00:43:38] And so, thank you.
[00:43:40] Well, in the Windows GUI world,
[00:43:42] when you need something that requires
[00:43:44] a higher level of context, it asks you.
[00:43:47] Pops a dialogue.
[00:43:47] You know, it pops a dialogue.
[00:43:49] It’s been doing that since, what, XP Service Pack 2, right?
[00:43:54] Yeah.
[00:43:55] Well, that was just UAC, but even before that.
[00:43:57] But, you know, you make the point.
[00:43:59] One of the things about a GUI
[00:44:00] is that you can layer on interface like this
[00:44:02] and it can interrupt.
[00:44:04] And everything stops and you can’t press Enter.
[00:44:06] You actually have to click.
[00:44:07] You can’t do a damn thing.
[00:44:08] Yeah.
[00:44:09] You have to click Allow.
[00:44:10] Yeah.
[00:44:10] Or OK.
[00:44:11] Right, well, we can actually do that.
[00:44:13] The problem is just scripts.
[00:44:15] So, we could do that.
[00:44:16] It’s terrible, yeah.
[00:44:16] But then, well, scripts have,
[00:44:18] there’s two actual problems with scripts.
[00:44:19] One is if you do an interactive mode on a command,
[00:44:23] while it’s in a script,
[00:44:23] it’ll hang the entire session.
[00:44:25] So, that’s bad.
[00:44:26] And so, in that case, you couldn’t get any approval.
[00:44:31] And so, knowing whether you’re in a script
[00:44:33] becomes then a security question.
[00:44:35] And right now, knowing whether you’re
[00:44:36] in interactive mode is kind of like,
[00:44:39] we can almost always get it right.
[00:44:41] Chet worked on that to get it in the .NET CLI now.
[00:44:45] In the .NET CLI now,
[00:44:47] does know whether you’re in interactive mode
[00:44:49] and does behave a little bit differently
[00:44:51] if it’s in interactive mode now, which is great.
[00:44:53] Right.
[00:44:54] One thing that’s in the newer version
[00:44:55] of GitHub Copilot CLI is this slash allow-all.
[00:45:01] OK.
[00:45:02] Which essentially says, don’t prompt me for permission.
[00:45:06] When you wanna do something, just go ahead and do it.
[00:45:09] And I saw that and I’m like,
[00:45:11] well, that’s very convenient.
[00:45:12] And you know, convenience is the enemy of security, right?
[00:45:16] I wanna know exactly what you’re,
[00:45:18] I don’t wanna see a bunch of stuff fly by.
[00:45:22] Yeah, I wanna know exactly what you’re gonna do.
[00:45:23] So, I don’t use that mode.
[00:45:25] Yeah, yeah.
[00:45:27] Yeah, it’s just,
[00:45:28] I don’t want you to break automation either.
[00:45:29] Like, it’s the challenge of writing good scripts.
[00:45:33] And, well, it is.
[00:45:35] And this is, you know,
[00:45:35] I think all these problems are solvable.
[00:45:37] If we look at them through the eyes of 2026.
[00:45:41] And, you know, I should have looked up
[00:45:43] how old that standard is.
[00:45:44] I didn’t, it’s absolutely ancient.
[00:45:45] It’d be hysterical if it was 1992,
[00:45:46] but I don’t think it is.
[00:45:48] But it’s quite old.
[00:45:50] And it has served very well.
[00:45:53] Nothing bad to say about it,
[00:45:55] except that it’s time for us to look forward.
[00:45:59] Modernize.
[00:46:00] Modernize.
[00:46:01] And there’s one thing in it
[00:46:03] that I personally dislike, but I doubt it’ll change,
[00:46:06] which is the ability to smash different flags together.
[00:46:09] And, you know, that’s the only thing.
[00:46:10] It’s called POSIX bundling and lets you do like dash AC
[00:46:14] if A is a flag and C is a flag.
[00:46:16] I don’t like that very much.
[00:46:17] But other than that, you know,
[00:46:19] it’s a really good standard.
[00:46:20] And it has served really, really well.
[00:46:23] And nobody would have ever thought about
[00:46:24] the kinds of things that we’re thinking about now,
[00:46:27] way back then.
[00:46:28] And it’s just time to take another look at it.
[00:46:29] And Open CLI is doing that.
[00:46:31] I don’t think it’s the only front
[00:46:32] that we’re gonna be looking at that.
[00:46:34] Although perhaps that will be the venue
[00:46:35] where we can take a look at a lot of different things
[00:46:38] and, you know, kind of update.
[00:46:41] It’s time for that.
[00:46:42] Yeah.
[00:46:43] And it does speak to this evolving way
[00:46:45] of interacting with software.
[00:46:47] I do, it is really something to watch
[00:46:50] an LLM write prompts like that.
[00:46:54] Like spit out a series of commands.
[00:46:56] It is.
[00:46:57] And it’s, I think it’s awesome.
[00:46:59] It’s just, it’s a very nice way to communicate,
[00:47:03] you know, back and forth,
[00:47:04] as long as the commands all stay simple
[00:47:07] and easy to understand.
[00:47:09] Which it’s up to the people writing the CLIs to do that.
[00:47:13] Yeah.
[00:47:15] Yeah.
[00:47:15] And back to that question of who’s writing the CLI
[00:47:17] and what’s for it,
[00:47:18] which like you said is any piece of software
[00:47:19] someone needs to interact with,
[00:47:21] you should probably be making the CLI first,
[00:47:23] then defining a GUI
[00:47:24] or whatever other interfaces you want.
[00:47:26] Unless you hear that statement
[00:47:28] and know what’s wrong for your app.
[00:47:29] And there are certainly apps that it’s,
[00:47:31] but if you don’t know what’s wrong,
[00:47:33] think about it.
[00:47:33] Try to think about whether that’s,
[00:47:35] yeah, think if it makes sense.
[00:47:38] I also saw this with the Azure CLI,
[00:47:40] which is that often the new feature shows up the CLI first
[00:47:43] and then the portal caught up sometime later.
[00:47:46] So, you know, the other side of this is
[00:47:48] you can ship faster when your interface
[00:47:51] is just an additional parameter call in the CLI
[00:47:56] and it just, it takes time to roll that up into the UX.
[00:47:59] Well, it does.
[00:48:00] And the Azure CLI is probably one of the easier ones
[00:48:02] because it has a lot of standards around,
[00:48:04] the CLI looks the same across a whole lot of different,
[00:48:07] a lot of problems have already been solved in,
[00:48:09] I’m sorry, in the GUI.
[00:48:11] A lot of problems are already solved in that GUI.
[00:48:12] So if you’re gonna write to a GUI,
[00:48:14] it’s probably a pretty easy one.
[00:48:16] But even so, the CLI allows you to get through prototype
[00:48:19] and find out if it’s even a good idea
[00:48:21] before you start putting any time
[00:48:23] into the arrangement of things.
[00:48:26] You have to start worrying about your semantics,
[00:48:28] your words before you start worrying
[00:48:29] about how those words lay out.
[00:48:31] And I think that’s a really healthy way
[00:48:32] to look at software as opposed to first looking at
[00:48:36] what’s the shape, what’s the pretty,
[00:48:38] what color should it be?
[00:48:39] What’s the color, yeah, yeah.
[00:48:41] Which is terribly important, even a GUI.
[00:48:43] I mean, I’m not-
[00:48:44] Eventually, eventually.
[00:48:46] I can’t design a UI for the life of me,
[00:48:48] but it’s decent, a GUI, not a GUI.
[00:48:51] A CLI I can design fairly well.
[00:48:53] What I like about this whole thinking is like,
[00:48:55] it’s about the functionality.
[00:48:57] Exactly, that’s exactly the point.
[00:49:00] And another thing that can drive you away from one
[00:49:02] is if you have a lot of data,
[00:49:04] it’s not a real easy way to have-
[00:49:06] No, that’s not what this is for.
[00:49:07] If you’re into GUIDs,
[00:49:08] if somebody has to enter GUIDs
[00:49:09] and you can’t abbreviate enough
[00:49:11] to say any four letters of the GUIDs will be good enough,
[00:49:14] then, you know, because we do it with commits
[00:49:17] all the time.
[00:49:18] Well, now you bring up a great point,
[00:49:20] which is that if you’re thinking CLI first,
[00:49:22] how does that change the way you craft parameters?
[00:49:26] Exactly.
[00:49:27] That’s absolutely true.
[00:49:27] The way you would manage data.
[00:49:28] You don’t want to put that in a prompt.
[00:49:30] You’d put it in a file and port it to the file.
[00:49:32] Yeah, yeah, absolutely, absolutely.
[00:49:35] Is that actually good for a GUI or another interface?
[00:49:38] I don’t know.
[00:49:39] It is interesting to think in those terms.
[00:49:42] It really is.
[00:49:44] I think it’s a good piece to our conversation.
[00:49:47] I don’t think it’s the end of our conversation.
[00:49:48] I just think it’s a big part,
[00:49:50] particularly this conversation we’re having right now
[00:49:52] where everything’s changing around us
[00:49:53] and we’re all trying to figure out
[00:49:54] which way the ground is.
[00:49:56] And in that world,
[00:49:57] I think that this is one of the grounding pieces
[00:49:59] is to say, I have something.
[00:50:01] I want shared.
[00:50:03] This is a way I can share it.
[00:50:04] And this is a way that doesn’t depend on a service to share.
[00:50:07] It can certainly be wrapped by a service.
[00:50:09] That’s great.
[00:50:10] But if you try to write your service first
[00:50:11] and then you write your CLI second, good luck
[00:50:14] because you’ve already got too much code in your library.
[00:50:16] If you write your library first and then your CLI,
[00:50:18] if you write your CLI, design your CLI first
[00:50:20] or design it alongside,
[00:50:22] then your library may make more sense.
[00:50:24] Your web API may make more sense.
[00:50:29] Various different pieces of your overall puzzle
[00:50:31] may make more sense.
[00:50:32] Yeah, thinking through your parameters
[00:50:34] before you build your backend even at all of these places.
[00:50:38] How would I want to invoke this?
[00:50:40] What would it look like?
[00:50:41] Yeah, certainly makes testing easier too.
[00:50:45] Sure does.
[00:50:45] Yeah, very automatable
[00:50:47] and work through all the different parameters.
[00:50:48] That’s exciting.
[00:50:49] That’s a great way to think about this Kathleen as usual.
[00:50:52] You got my head going.
[00:50:54] Yeah.
[00:50:55] Well, one thing about the little project I’m working on
[00:50:58] is if anyone is interested in source generators
[00:51:03] and they want to look at a non-trivial source generator,
[00:51:06] some fantastic, there’s some fantastic blogs out there
[00:51:10] and I’ll send you resources on two of them
[00:51:12] on if you just want to write hello world.
[00:51:14] Hello world for a source generator
[00:51:16] is rewriting two string for enums.
[00:51:18] That is the hello world.
[00:51:20] And so if you want to go beyond that,
[00:51:22] then it gets really hard, really quick
[00:51:24] and it is not linear.
[00:51:25] It is very non-linear.
[00:51:28] It goes up fast and I have tricks.
[00:51:30] I’ve been doing this a long time.
[00:51:32] I have some really good tricks
[00:51:33] and I was showing somebody who’s a really hot programmer.
[00:51:36] I was so impressed that he said this
[00:51:37] and it was a particular thing I did
[00:51:39] and he goes, oh, I never thought of that.
[00:51:40] That’s going to save me a lot of time.
[00:51:42] And so I’m going to be giving a talk
[00:51:45] at Techarama on that.
[00:51:46] And I’m also talking around on C-sharp,
[00:51:50] both C-sharp gotchas and modern C-sharp.
[00:51:55] What can your code look like today and why is that good?
[00:51:57] So, that’s the other things I’m working on
[00:52:00] is where C-sharp is at.
[00:52:03] I was so busy building it.
[00:52:05] I couldn’t really talk about it.
[00:52:07] And that was a great frustration
[00:52:08] and now I can talk about that.
[00:52:11] And then Richard, Carl, you know that
[00:52:14] I did a workshop for a long time,
[00:52:16] which was, I become a better C-sharp programmer.
[00:52:19] I’ll make you a better C-sharp programmer.
[00:52:20] Yeah, I remember, classic.
[00:52:22] And so I am hoping I’m in progress.
[00:52:25] I think I’m going to be able to release that
[00:52:28] and put that together in a big way.
[00:52:31] And so that along with the modernizing
[00:52:33] and then my talk at Techarama
[00:52:36] is staying sane while writing
[00:52:38] as Roslyn’s source generator.
[00:52:40] Nice.
[00:52:42] I realize there’s at least two more shows here.
[00:52:44] You’re thinking about what modern C-sharp looks like
[00:52:46] is a whole other show
[00:52:48] and everything to do with Roslyn’s easily a show too.
[00:52:51] Yeah.
[00:52:52] The C-sharp gotchas is actually another show too.
[00:52:54] So we will not be waiting four years again.
[00:52:56] I’m quite sure of that.
[00:52:58] No, no, I think we better not.
[00:53:00] We’ll figure that out.
[00:53:02] So much fun to talk to you again.
[00:53:03] Yeah.
[00:53:04] I’m glad you’re well.
[00:53:05] Oh, it’s great.
[00:53:06] Yeah, we are very happy for that.
[00:53:07] Yeah, and I’m so glad to be well.
[00:53:10] So glad to be here with y’all today
[00:53:12] and ready to go and shovel my driveway.
[00:53:15] Yeah. Nice.
[00:53:16] That is, or snowblower too,
[00:53:17] but there’s some shoveling involved too.
[00:53:19] And we’re almost neighbors
[00:53:20] so we should be hanging out more.
[00:53:22] I know, I know.
[00:53:24] Let me, let’s get in touch.
[00:53:25] So let’s do it.
[00:53:26] Yeah, we’ll be in touch.
[00:53:27] Yeah. That sounds good.
[00:53:28] All right, Kathleen, thanks again.
[00:53:30] And thank you, dear listener.
[00:53:32] We’ll talk to you next time on .NET Rocks.
[00:53:35] .NET Rocks is brought to you by Franklin’s Net
[00:53:38] and produced by Plop Studios,
[00:53:40] a full-service audio, video and post-production facility
[00:53:44] located physically in New York City.
[00:53:47] For more information, go to www.net.com.
[00:53:50] And if you’d like to see more videos
[00:53:52] from the show,
[00:53:53] check out the show at www.net.com.
[00:53:56] The show is brought to you by Franklin’s Net
[00:53:58] and produced by Plop Studios,
[00:54:00] a full-service audio, video, and post-production facility
[00:54:04] physically in New London, Connecticut,
[00:54:06] and of course, in the cloud.
[00:54:08] Online at pwop.com.
[00:54:11] Visit our website at dotmetrocks.com
[00:54:15] for RSS feeds, downloads, mobile apps, comments,
[00:54:19] and access to the full archives,
[00:54:21] going back to show number one,
[00:54:23] recorded in September, 2002.
[00:54:25] And make sure you check out our sponsors.
[00:54:27] They keep us in business.
[00:54:29] Now go write some code.
[00:54:31] See you next time.
[00:54:32] Got transmitter bands by the FCC.
[00:54:36] Yes, I’m a toy boy.
[00:54:39] Life is hard.
[00:54:41] Pay my taxes with my credit card.