[00:00] (0.00s)
                    Hey everyone, welcome back to the
                 
            
                
                    [00:01] (1.28s)
                    channel. My name is John and this is
                 
            
                
                    [00:02] (2.64s)
                    your modern tech breakdown. Today I'm
                 
            
                
                    [00:04] (4.48s)
                    looking at a set of new open-source
                 
            
                
                    [00:06] (6.16s)
                    tools that Apple announced at WWDC for
                 
            
                
                    [00:09] (9.04s)
                    Linux containers. Let's jump into
                 
            
                
                    [00:21] (21.00s)
                    it. So, Apple announced some new tools
                 
            
                
                    [00:23] (23.60s)
                    that will help folks building Linux
                 
            
                
                    [00:25] (25.44s)
                    containers on a Mac. Specifically,
                 
            
                
                    [00:27] (27.44s)
                    they've released a containerization
                 
            
                
                    [00:29] (29.20s)
                    package that allows a Mac to run a Linux
                 
            
                
                    [00:31] (31.60s)
                    container as well as a command line
                 
            
                
                    [00:33] (33.68s)
                    interface to manage it. These tools use
                 
            
                
                    [00:35] (35.84s)
                    Apple's Swift programming language and
                 
            
                
                    [00:37] (37.92s)
                    the virtualization framework and will
                 
            
                
                    [00:39] (39.84s)
                    speed up the development of containers
                 
            
                
                    [00:41] (41.36s)
                    by making it quicker and easier to run
                 
            
                
                    [00:43] (43.36s)
                    the build test iteration loop. There are
                 
            
                
                    [00:45] (45.52s)
                    a few interesting details to talk about.
                 
            
                
                    [00:47] (47.44s)
                    First, the package creates a small,
                 
            
                
                    [00:49] (49.52s)
                    highly optimized VM for each container.
                 
            
                
                    [00:52] (52.32s)
                    And if you're like me, you're probably
                 
            
                
                    [00:53] (53.76s)
                    thinking, "Isn't a VM redundant with a
                 
            
                
                    [00:55] (55.60s)
                    container?" Yes, but the goal here is to
                 
            
                
                    [00:58] (58.08s)
                    make it easier to work on building
                 
            
                
                    [00:59] (59.76s)
                    containers that will be run elsewhere.
                 
            
                
                    [01:02] (62.08s)
                    This isn't a production environment
                 
            
                
                    [01:03] (63.68s)
                    tool. This is a tool for testing and
                 
            
                
                    [01:05] (65.68s)
                    building, so it does make sense from
                 
            
                
                    [01:07] (67.52s)
                    that point of view. Also, Apple has
                 
            
                
                    [01:09] (69.36s)
                    claimed sub-second start times for the
                 
            
                
                    [01:11] (71.04s)
                    VM, which sounds pretty great. I don't
                 
            
                
                    [01:12] (72.88s)
                    know what other container tools
                 
            
                
                    [01:14] (74.24s)
                    typically require to start up, but this
                 
            
                
                    [01:15] (75.92s)
                    sounds good to me and seems like it
                 
            
                
                    [01:17] (77.60s)
                    would help developers iterate faster,
                 
            
                
                    [01:19] (79.36s)
                    which is always good. And if you're like
                 
            
                
                    [01:21] (81.12s)
                    me, you're probably also thinking,
                 
            
                
                    [01:23] (83.04s)
                    "Wait, Macs run on Apple Silicon, which
                 
            
                
                    [01:25] (85.20s)
                    is an ARMbased architecture. Most Linux
                 
            
                
                    [01:27] (87.76s)
                    containers are probably going to be run
                 
            
                
                    [01:29] (89.68s)
                    on Intel x86. How is this going to
                 
            
                
                    [01:32] (92.72s)
                    work?" Well, the framework includes x86
                 
            
                
                    [01:35] (95.44s)
                    emulation with Rosetta 2. So, problem
                 
            
                
                    [01:38] (98.00s)
                    solved. And lastly, these new tools will
                 
            
                
                    [01:40] (100.16s)
                    require a Mac running Apple Silicon and
                 
            
                
                    [01:42] (102.48s)
                    Mac OS 15 or newer. So, if you're still
                 
            
                
                    [01:44] (104.64s)
                    holding on to an Intel Mac, you're out
                 
            
                
                    [01:46] (106.32s)
                    of luck on this one. But it's probably
                 
            
                
                    [01:48] (108.00s)
                    getting time to upgrade that hardware
                 
            
                
                    [01:49] (109.76s)
                    anyway. The new Mac OS Tahoe might be
                 
            
                
                    [01:52] (112.00s)
                    the last operating system to support
                 
            
                
                    [01:53] (113.60s)
                    Intel Max. I think I did see Apple make
                 
            
                
                    [01:55] (115.52s)
                    an announcement about that. But anyway,
                 
            
                
                    [01:57] (117.84s)
                    that's all I have for you on these
                 
            
                
                    [01:59] (119.12s)
                    tools. As always, thanks for watching.
                 
            
                
                    [02:00] (120.72s)
                    Please like and subscribe and I will
                 
            
                
                    [02:02] (122.00s)
                    catch you next