Slashdot Mirror

Marco Arment was the original developer behind Tumblr, the original developer behind Instapaper (i.e. the first big "read it later" service on mobile), is currently the developer for the Overcast podcast app and service, but is probably most well-known in Apple tech circles these days as a blogger and podcaster (he hosts a few podcasts, the biggest one being the Accidental Tech Podcast with John Siracusa and Casey Liss).

As for why you should care? You shouldn't. Mind you, I read his blog and regularly listen to his podcasts, so I'd lump myself in as a fan of the things he has to say (which isn't to say that I agree with them, just that I like hearing them). I was fine with Slashdot covering his blog entry last year when he railed against the quality of software that Apple was putting out, because even though he later regretted having made that post, it still did an excellent job at coalescing and reflecting a broader sense of dissatisfaction among Apple users at the time. But his random thoughts on the shape of the iPhone X? Even I don't think that warrants Slashdot coverage. It was something I enjoyed reading yesterday, but it doesn't warrant reposting here.

+1 for Radiolab. The best explanation I've come up with for it so far is that it's a variety series of incredibly well-produced audio micro-documentaries. I listened to one on a whim (Bigger than Bacon, which was about the mystery of a crackling sound one of their reporters used to hear at boat dock near their house) and was immediately hooked. It finds the perfect balance between being educational and entertaining.

I also love their More Perfect podcast. It's worth a listen for anyone who wishes they knew more about the US Supreme Court but doesn't actually want to devote any time to the subject. They manage to find the human interest side to each story and present them in a way that keeps you on the edge of your seat, despite the fact that in most of the cases I knew how the cases would turn out.

As for my complete list and why I like them, it's pretty short:
- Accidental Tech Podcast - Three guys talking about tech and cars. They play well off each other and, between the three, usually have some decent insight into the tech community and how it interacts with a mostly inscrutable company (i.e. Apple).

- Radiolab - See above

- Radiolab Presents: More Perfect - See above

- Serial - Everyone and their grandma listens to this one, so it needs no explanation

- Under the Radar - Two guys talking iOS development. I'm not in the space, but it's always under 30 minutes, they stay on topic, and they frequently provide a veteran's perspective that runs contrary to what an outsider like me might think makes sense, so I find it to be a decent listen. Others will likely find it boring.

I'm also going to give the just-begun The Important Thing a shot in the next few days, since the guy doing it writes a frequently-insightful blog that I really enjoy reading and is typically really good on the other podcasts I've heard him on. I expect it'll become part of my usual group of podcasts, but I can't yet offer that recommendation.

The Accidental Tech Podcast had an interview with Chris Lattner where he discussed the future of Swift as a systems language and compared it to Rust. Rust has a very upfront memory ownership model that requires programmers to be explicit about memory management. This allows Rust to have great performance and allows the compiler to ensure memory is used safely that is not an option with C.

With Swift, either you pretty much don't think about memory (it uses Automatic Reference Counting so you only need to care about cycles), or you need to go down to C-style memory semantics with the various Unsafe constructions. There are cases where you could get much better performance because the programmer knows the lifecycle of the objects being used, but that can't currently be expressed in Swift. It can be expressed in Rust.

To be a good systems programming language, Chris said that Swift will need to create a memory ownership model (and mentioned Rust as having ideas that might apply). He would like that ownership model to be opt-in for specific pieces of your code that require it: most people could use ARC, while people that need performance in a specific piece could be more detailed about the memory management. It's on his list of things that Swift will acquire over the years so it can achieve world domination.

So there are really pretty good reasons that Mozilla put together Rust. The browser is probably the most widely exposed attack surface right now, and the history of buffer overloads means there needed to be a safer way to code.

Once on a conference, I talked to Casey Liss (co-host of the ATP podcast). He's now an iOS developer, but at the time was still a .NET developer. He explained the basics of LINQ to me. Basically, it's an extension of the language for querying the database. In other languages, including Swift and Objective-C, you'll type your query in quotes. The compiler has no idea what's between the quotes, it's just a string for all it cares.

In C# with LINQ, the compiler offers code completion and type checking for queries and I thought that was great. I know Swift and Objective-C have Core Data, but LINQ is much more integrated. Why doesn't have Swift something like that?