Under the Radar

00:00:00 ◼   ► Welcome to Under the Radar,

00:00:01 ◼   ► a show about independent iOS app development.

00:00:03 ◼   ► I'm Mark Arment.

00:00:04 ◼   ► - And I'm David Smith.

00:00:05 ◼   ► Under the Radar is never longer than 30 minutes,

00:00:07 ◼   ► so let's get started.

00:00:08 ◼   ► - It's kind of hard to pick a topic a lot in the summertime

00:00:12 ◼   ► because we're mostly just keeping our heads down working

00:00:15 ◼   ► or going on vacations here and there,

00:00:16 ◼   ► and we're just kind of plowing through things

00:00:19 ◼   ► we have to do for the fall releases.

00:00:22 ◼   ► There's not a lot going on,

00:00:23 ◼   ► so we kind of wanted to just take this episode

00:00:25 ◼   ► to basically do like a status update

00:00:27 ◼   ► of what we've been working on,

00:00:29 ◼   ► why, and then what we're kind of planning

00:00:32 ◼   ► for the imminent summer or imminent fall releases

00:00:36 ◼   ► of all these OSes and possible new hardware and everything

00:00:39 ◼   ► 'cause we're kind of in the home stretch now.

00:00:42 ◼   ► The pace of betas from Apple has been steady,

00:00:47 ◼   ► but the pace of changes in each beta

00:00:49 ◼   ► has been dropping dramatically,

00:00:51 ◼   ► so you can tell the OS betas are stabilizing.

00:00:55 ◼   ► The tooling has not changed much in the last few weeks.

00:00:58 ◼   ► There hasn't been an Xcode release in a few weeks,

00:01:00 ◼   ► even a couple of betas ago,

00:01:02 ◼   ► and so everything seems to be coasting in for landing here.

00:01:07 ◼   ► Like, we're getting close.

00:01:08 ◼   ► The new OSes are imminent.

00:01:10 ◼   ► They are probably going to have some kind of event

00:01:13 ◼   ► and release of the new OSes

00:01:15 ◼   ► within about three or four weeks,

00:01:17 ◼   ► so we're really in the home stretch here,

00:01:19 ◼   ► and so we kind of wanted to just go over like

00:01:22 ◼   ► what have we been doing

00:01:23 ◼   ► and where are we in our summer progress.

00:01:26 ◼   ► So, Dave, what have you been doing?

00:01:29 ◼   ► - Yeah, so one of my big goals for,

00:01:33 ◼   ► like, I ended up structuring my work this summer

00:01:35 ◼   ► slightly different than I think I have in other years

00:01:37 ◼   ► where the initial betas, as they came out,

00:01:41 ◼   ► were pretty rough this year.

00:01:43 ◼   ► Like, things just seemed unsettled,

00:01:47 ◼   ► at least for those first few betas,

00:01:49 ◼   ► and so I just felt bad and tricky

00:01:52 ◼   ► about diving into them too much right away.

00:01:55 ◼   ► Like, it just didn't seem like a good fit

00:01:57 ◼   ► both for my schedule and the amount I'd be working as well.

00:01:59 ◼   ► It was just not gonna be a great idea,

00:02:02 ◼   ► and especially because iOS 13 drops support

00:02:06 ◼   ► for a number of the sort of older devices.

00:02:10 ◼   ► It's kind of an awkward year or two

00:02:12 ◼   ► to be too much all in on the new stuff,

00:02:14 ◼   ► and I think at this point,

00:02:15 ◼   ► I expect to not drop support for iOS 12

00:02:19 ◼   ► for at least probably, I wanna say, a year,

00:02:23 ◼   ► but it seemed like a year to sort of focus more

00:02:25 ◼   ► on, the front part of my summer would be focused

00:02:28 ◼   ► on just getting things in a really good place

00:02:32 ◼   ► rather than necessarily diving too much into the new stuff,

00:02:35 ◼   ► and especially 'cause I think a lot of the new things

00:02:37 ◼   ► and the new capabilities that I'll be working on are,

00:02:41 ◼   ► there'll be some new apps that I'll be working on,

00:02:43 ◼   ► thanks to the new space in my app catalog that I have

00:02:47 ◼   ► from retiring, a number of things

00:02:49 ◼   ► that I used to be weighing me down.

00:02:52 ◼   ► So that's like from earlier in the summer,

00:02:53 ◼   ► if you remember, we did a whole episode

00:02:55 ◼   ► about getting rid of things.

00:02:55 ◼   ► That process is ongoing and continuing to go well

00:02:59 ◼   ► to streamline things there.

00:03:00 ◼   ► And I'll be sort of writing some new things,

00:03:03 ◼   ► and the nice thing with new things is there's not much

00:03:06 ◼   ► so far that I've seen that's like,

00:03:07 ◼   ► you need to be there on day one

00:03:10 ◼   ► to really sort of take advantage of things.

00:03:12 ◼   ► It's okay to be a little bit more decline,

00:03:14 ◼   ► and I also, I think too, I'm very curious

00:03:17 ◼   ► to see where we go hardware-wise this fall,

00:03:21 ◼   ► and that may sort of inform a little bit

00:03:24 ◼   ► what direction I go into.

00:03:25 ◼   ► And so instead, I've just been working on

00:03:28 ◼   ► making the existing apps that I have better.

00:03:30 ◼   ► And the first one, that big update that I did,

00:03:32 ◼   ► was a big update to Pedometer++,

00:03:34 ◼   ► where, and I think this is very much one of those

00:03:36 ◼   ► like tech debt, niggling features,

00:03:40 ◼   ► problems that affect .01% of users,

00:03:43 ◼   ► but for that one, .01% of users

00:03:45 ◼   ► are really annoying kind of bugs.

00:03:47 ◼   ► And that was just sort of like this big update

00:03:49 ◼   ► that had no big marquee features,

00:03:51 ◼   ► but lots and lots of little features.

00:03:54 ◼   ► And the most amusing part of this particular update

00:03:56 ◼   ► is that it, for the first time ever,

00:04:00 ◼   ► required or at least encouraged me to write unit tests,

00:04:05 ◼   ► which, and it was shocking,

00:04:07 ◼   ► we've talked about this many times on the show,

00:04:08 ◼   ► that unit tests are not my favorite thing,

00:04:10 ◼   ► but I ended up actually writing some unit tests,

00:04:13 ◼   ► primarily because the situation that I was trying to fix

00:04:17 ◼   ► was one of these really weird database things,

00:04:20 ◼   ► where if a user had a particular structure of data,

00:04:24 ◼   ► and then they did a particular operation,

00:04:26 ◼   ► and then it merged with their Apple Watch,

00:04:28 ◼   ► then you could end up in this sort of situation

00:04:31 ◼   ► where you'd have some data inconsistency.

00:04:33 ◼   ► But it was incredibly hard to actually create

00:04:36 ◼   ► that situation where this would happen.

00:04:38 ◼   ► And so that becomes a situation where like,

00:04:40 ◼   ► all right, unit test is the right answer here,

00:04:42 ◼   ► where I can very sort of consistently go through all,

00:04:45 ◼   ► have the process of the unit test,

00:04:48 ◼   ► create all the steps to create this problematic case,

00:04:52 ◼   ► check that my fix is in fact working,

00:04:55 ◼   ► and then be confident about it.

00:04:57 ◼   ► And I wrote it, it worked great.

00:04:59 ◼   ► Everybody speaks to that.

00:05:02 ◼   ► And I think when you've talked about

00:05:05 ◼   ► sort of automated testing in the past,

00:05:06 ◼   ► it's one of those things where I feel like

00:05:08 ◼   ► it is problematic when it becomes,

00:05:10 ◼   ► like you become zealous about it,

00:05:13 ◼   ► and you start, it's like everything has to be unit tested,

00:05:16 ◼   ► and everything, your tests are just as important

00:05:18 ◼   ► as your code.

00:05:18 ◼   ► I find that kind of development perspective

00:05:21 ◼   ► a very sort of inflexible and non-pragmatic view.

00:05:26 ◼   ► But unit tests are just a, they're just other,

00:05:28 ◼   ► like all you're doing is just writing other code

00:05:30 ◼   ► to test your other code, and doing it

00:05:33 ◼   ► with some of the affordances of the tooling.

00:05:35 ◼   ► And so in that sense, the pragmatic thing is sometimes

00:05:38 ◼   ► to just use your code that way.

00:05:40 ◼   ► And I wrote a unit test rather than,

00:05:43 ◼   ► the other version I could have done

00:05:44 ◼   ► is would have had some utility method

00:05:45 ◼   ► that I pass an argument into the app on launch,

00:05:48 ◼   ► and it goes through and messes with the database

00:05:50 ◼   ► in an inappropriate way to get into that situation,

00:05:54 ◼   ► and I would run my test that way.

00:05:55 ◼   ► But functionally, I just took that code,

00:05:58 ◼   ► and instead of kind of the awkward place

00:06:00 ◼   ► of putting it actually into the code itself,

00:06:03 ◼   ► that I don't want to ship to customers necessarily,

00:06:06 ◼   ► because I don't want to somehow, down the road,

00:06:09 ◼   ► accidentally create this bad situation

00:06:11 ◼   ► in a customer's database.

00:06:13 ◼   ► It's like putting it in the unit test

00:06:14 ◼   ► that was pragmatic, made sense, and worked fine.

00:06:17 ◼   ► But I have now officially written my first unit test

00:06:21 ◼   ► after doing this professionally for like a decade.

00:06:23 ◼   ► - How do you feel?

00:06:24 ◼   ► Do you feel like a different kind of person now?

00:06:27 ◼   ► - I feel remarkably the same.

00:06:29 ◼   ► - Do you feel like you want to start testing everything?

00:06:32 ◼   ► - Just all the things.

00:06:34 ◼   ► I can go crazy and just, I'll start testing,

00:06:37 ◼   ► like have all that have the,

00:06:38 ◼   ► every function I write now needs to have a precondition

00:06:42 ◼   ► and a postcondition, I think, remember this right?

00:06:44 ◼   ► Is that how that works?

00:06:45 ◼   ► - Yeah.

00:06:46 ◼   ► - Remember, wasn't there?

00:06:47 ◼   ► This is where you started getting to,

00:06:48 ◼   ► like back in college, I remember taking

00:06:50 ◼   ► a software testing course, and it was this very tedious,

00:06:55 ◼   ► kind of mathematical approach to software development,

00:07:00 ◼   ► where you had this thing where every function

00:07:02 ◼   ► was supposed to have a particular precondition,

00:07:04 ◼   ► like these are the possible ranges of values for the inputs,

00:07:07 ◼   ► and then these are the, the postcondition is the value,

00:07:09 ◼   ► possible values for the outputs,

00:07:11 ◼   ► and you would like structure,

00:07:12 ◼   ► and so it's almost at a certain point,

00:07:14 ◼   ► you're like, your code becomes this giant equation

00:07:16 ◼   ► that has to be perfect because you've sort of proved

00:07:19 ◼   ► at every point that the input and output is correct,

00:07:21 ◼   ► so the total output has to be correct,

00:07:23 ◼   ► but I've never actually found that to be useful in practice.

00:07:28 ◼   ► So, but no, it's, I mean, you're testing it is,

00:07:30 ◼   ► it's just code, like I think that's the thing that is,

00:07:33 ◼   ► like the way that I view it is that

00:07:34 ◼   ► it is a different type of code, and it is useful

00:07:38 ◼   ► insofar as it's like sometimes you have to write code

00:07:41 ◼   ► to test your other code and to make sure it works,

00:07:43 ◼   ► but beyond that, it's just a tool that's nice there,

00:07:48 ◼   ► and like, but I don't really see, you know,

00:07:49 ◼   ► like I have a couple, so now I have a few unit tests,

00:07:52 ◼   ► and probably before I do releases going forward,

00:07:55 ◼   ► I'll like run my test suite once, just because like why not?

00:07:58 ◼   ► It's, you know, it's sitting there.

00:08:01 ◼   ► - That's kind of the point.

00:08:03 ◼   ► - But like I don't expect it to be the kind of thing

00:08:04 ◼   ► where like I'll do continuous integration

00:08:06 ◼   ► and have it like running all the time

00:08:07 ◼   ► and have an Xcode server sitting somewhere,

00:08:09 ◼   ► like running this and like doing all that kind of stuff.

00:08:12 ◼   ► Like that doesn't, I mean, that's just not the way I work.

00:08:16 ◼   ► Like I don't think of, I don't think of my code that way,

00:08:19 ◼   ► and honestly, in a weird way, like I'm not,

00:08:22 ◼   ► there's so many aspects too, I think,

00:08:24 ◼   ► where because I'm a solo developer, I so often,

00:08:28 ◼   ► my code is not always in a shippable state.

00:08:32 ◼   ► Like I'm sure there are times that I'm,

00:08:34 ◼   ► like I'm breaking the build, and I'm doing it,

00:08:37 ◼   ► and it's fine because I'm not affecting someone else

00:08:39 ◼   ► when I do that.

00:08:41 ◼   ► Like I sometimes just wanna, like,

00:08:44 ◼   ► I mean this is years ago now, but when I used to work

00:08:46 ◼   ► in a bigger company, like it was a big deal

00:08:48 ◼   ► to sort of ever check in code that would break unit tests.

00:08:52 ◼   ► And obviously you can make your own development branches,

00:08:54 ◼   ► and like there's ways to work around this,

00:08:57 ◼   ► but it was a big deal, and it was something

00:08:58 ◼   ► that you had to have in your mind,

00:09:00 ◼   ► where sometimes I will just be like checking in code,

00:09:03 ◼   ► and it's like sometimes my commit message,

00:09:04 ◼   ► it just like seems to kinda work.

00:09:07 ◼   ► (laughing)

00:09:08 ◼   ► And I'm just like, and then like two commits later,

00:09:11 ◼   ► it's like actually that didn't work at all.

00:09:12 ◼   ► And it's like that's okay, because I'm just having

00:09:15 ◼   ► a little conversation with my version control

00:09:17 ◼   ► about my process as I go, and it's much,

00:09:21 ◼   ► like commits are lightweight and great,

00:09:23 ◼   ► so I can just make as many of them as I want,

00:09:25 ◼   ► and they're just little checkpoints for me

00:09:27 ◼   ► if I wanna be like oh man, I went down

00:09:29 ◼   ► the totally wrong path here, let me just roll back.

00:09:33 ◼   ► And I can do that in kind of a lightweight way,

00:09:34 ◼   ► but yeah, anyway, so I've been down the road--

00:09:37 ◼   ► - Do you do branching much?

00:09:38 ◼   ► - Very little branching.

00:09:41 ◼   ► What I tend to do is I have like my actual,

00:09:45 ◼   ► like this is the version I ship,

00:09:47 ◼   ► and then the only time I typically branch

00:09:49 ◼   ► is if I am going to be working on a major update

00:09:54 ◼   ► while concurrently shipping minor bug fix updates.

00:10:01 ◼   ► So an example will be once I got this big update out

00:10:06 ◼   ► that has all these bug fixes for everyone,

00:10:08 ◼   ► I will likely make a branch for iOS 13,

00:10:11 ◼   ► and kind of work on that a little bit,

00:10:13 ◼   ► and then sort of work down that way.

00:10:15 ◼   ► But typically, that is the extent of what I'm doing,

00:10:18 ◼   ► and sometimes I also, I'm sure it's a terrible thing,

00:10:22 ◼   ► but sometimes I make those branches kind of retroactively.

00:10:26 ◼   ► I'll go down a path and be like huh,

00:10:29 ◼   ► I should probably make a branch of this at this point.

00:10:32 ◼   ► But it's all these weird, it's like these tricky things

00:10:35 ◼   ► with like code hygiene and structure where it's,

00:10:39 ◼   ► I have much more flexibility about it

00:10:41 ◼   ► because I'm just a single developer,

00:10:44 ◼   ► and like in the same way that unit tests exist

00:10:47 ◼   ► to make my life easier, you know,

00:10:49 ◼   ► like version control largely exists to make my life easier.

00:10:52 ◼   ► And so doing something that was more heavy-handed

00:10:55 ◼   ► or even just like, it's just never really clicked for me

00:10:58 ◼   ► when that's like okay, I'm gonna work on version 4.1.2.

00:11:02 ◼   ► Let me make the 4.1.2 branch and start working on that,

00:11:05 ◼   ► and then merge that into master and like do all that.

00:11:09 ◼   ► I mean, I'm even the, this is the,

00:11:12 ◼   ► it's like, I don't know, this is like Dave's confessional

00:11:13 ◼   ► where I'm like, I've actually changed masters

00:11:16 ◼   ► several times too.

00:11:17 ◼   ► - Wait, you can do that?

00:11:18 ◼   ► - Well, I just have like new master and like new new master.

00:11:21 ◼   ► (laughing)

00:11:22 ◼   ► - Oh no.

00:11:23 ◼   ► Master v2 final final final v1.

00:11:26 ◼   ► - Yep, exactly.

00:11:27 ◼   ► I've gone down that road too.

00:11:29 ◼   ► And like it works, like it's fine.

00:11:31 ◼   ► And I'm sure, yes, I'm sure there's some git command

00:11:33 ◼   ► I could actually do, but like, 'cause every now and then

00:11:36 ◼   ► if I actually like try, and I'm sure there's some like,

00:11:38 ◼   ► is this when I'm supposed to rebase or something?

00:11:41 ◼   ► - I don't know what that means.

00:11:42 ◼   ► - And rebase like hurts my head, but there's--

00:11:44 ◼   ► - There's a whole bunch of like advanced git maneuvers

00:11:46 ◼   ► that just break my brain and I just don't, I don't do,

00:11:49 ◼   ► I never, I just never do any of them.

00:11:50 ◼   ► I don't know what they mean, I'm scared to ever try them.

00:11:53 ◼   ► - Yeah, but like this is the thing where like sometime

00:11:55 ◼   ► I'll make a branch, I'll go down this path and like,

00:11:57 ◼   ► and then I'll go to merge it back into master.

00:12:00 ◼   ► And then there'll be like a big massive set

00:12:03 ◼   ► of conflicting changes or something in the,

00:12:05 ◼   ► and like I don't, I don't wanna like deal with that.

00:12:09 ◼   ► Like that's just busy work that isn't actually name important

00:12:12 ◼   ► because the name of the branch, that's the one I ship,

00:12:16 ◼   ► being called M-A-S-T-E-R is entirely like semantic.

00:12:20 ◼   ► Like who cares?

00:12:22 ◼   ► And so I'll just be like, it's like now I'll just be like,

00:12:24 ◼   ► let me just take whatever this feature branch

00:12:26 ◼   ► that I've been working on and I'll call it new master

00:12:29 ◼   ► or I'll call it Dave's awesome code and like,

00:12:33 ◼   ► this is what I'm shipping now.

00:12:35 ◼   ► - Super master. - It's fine, yeah.

00:12:36 ◼   ► And the thing is because like the way

00:12:40 ◼   ► that version control works, like whatever the most recently

00:12:43 ◼   ► worked on thing is like becomes the head of the tree

00:12:45 ◼   ► of like version control, like essentially the old master

00:12:48 ◼   ► just like withers away and dies and I never see it again.

00:12:51 ◼   ► And like that's fine, so.

00:12:53 ◼   ► - Wow, yes, you really are doing it more like a tree

00:12:56 ◼   ► 'cause you know, in an actual tree,

00:12:58 ◼   ► branches don't ever merge back into the trunk.

00:13:01 ◼   ► - That is true.

00:13:03 ◼   ► - So you're kind of like, you're doing it more semantically

00:13:06 ◼   ► to the word branch in its original meaning.

00:13:10 ◼   ► - Yeah, my branches go off and then sometimes they kind of

00:13:14 ◼   ► go back in towards the trunk but most of the time,

00:13:15 ◼   ► sometimes they just go off and become their own trees.

00:13:18 ◼   ► Like those really awesome trees where like the tree,

00:13:20 ◼   ► you know it's like basically what I'm doing is that

00:13:21 ◼   ► you know when the tree falls down and then a new tree

00:13:25 ◼   ► is like springs out of the trunk of the old tree,

00:13:28 ◼   ► so you have like a tree that's horizontal

00:13:29 ◼   ► and then another one comes up out of it vertically?

00:13:31 ◼   ► That is my version control system.

00:13:34 ◼   ► - That's fantastic.

00:13:35 ◼   ► No, I mean, and I think there, and first of all,

00:13:37 ◼   ► before I forget, I actually use branching a little closer

00:13:40 ◼   ► to the way I think we're quote supposed to do it

00:13:44 ◼   ► but still not to the way that a large organization

00:13:46 ◼   ► will do it 'cause you know, I do branching where I mostly

00:13:50 ◼   ► am doing most of my work on the master branch

00:13:52 ◼   ► for most of the year but I will create branches

00:13:55 ◼   ► if I'm doing like a big experiment that requires like

00:13:58 ◼   ► what if I tear apart the UI and rearrange things

00:14:01 ◼   ► in a really big way that I know would take a lot more work

00:14:04 ◼   ► before it would ever become shippable?

00:14:06 ◼   ► I'll create a branch for that that like I'm gonna change

00:14:08 ◼   ► a whole bunch of code in a way that I probably don't want

00:14:11 ◼   ► in the master and might never want in the master

00:14:13 ◼   ► so I'm gonna do this experiment off to the side.

00:14:16 ◼   ► Another way, another time I create branches

00:14:18 ◼   ► and by the way, most of those just get abandoned

00:14:21 ◼   ► and then another way I do them more frequently

00:14:23 ◼   ► is whenever there is a new beta season

00:14:26 ◼   ► so I basically, WBC Monday every year,

00:14:30 ◼   ► I create a new branch for this year's iOS 13

00:14:34 ◼   ► and that branch requires iOS 13 so I get all the most fun

00:14:38 ◼   ► warnings in Xcode about everything that's deprecated

00:14:41 ◼   ► and everything that's changed and everything,

00:14:42 ◼   ► all these new warnings and I just slowly plow through

00:14:45 ◼   ► and work on that branch throughout the summer

00:14:47 ◼   ► as I get things done and it's for the same reason

00:14:50 ◼   ► that you kind of mentioned earlier of like I want to be able

00:14:53 ◼   ► to ship updates to the master branch if necessary

00:14:56 ◼   ► for the old OS over the summer and this summer,

00:14:59 ◼   ► I've been doing a lot more of that than I ever had before.

00:15:02 ◼   ► I think almost every summer, I've issued like between zero

00:15:06 ◼   ► and one update in the entire summer for the old OS

00:15:08 ◼   ► because I basically stop working on that completely

00:15:11 ◼   ► and put all my resources behind the new OS.

00:15:13 ◼   ► This year's a little bit different.

00:15:15 ◼   ► You mentioned this too.

00:15:16 ◼   ► This year is that, you know, it's,

00:15:19 ◼   ► iOS 13 not only is in a pretty rough state,

00:15:22 ◼   ► you know, and wasn't in a pretty rough state for a while

00:15:24 ◼   ► and might still be but also it is the first update

00:15:27 ◼   ► in a while to drop all device compatibility

00:15:29 ◼   ► and so a combination of those two things I think

00:15:32 ◼   ► is gonna result in a slower than usual adoption rate

00:15:35 ◼   ► and also there's not a lot in iOS 13

00:15:39 ◼   ► that I really must adopt on day one.

00:15:41 ◼   ► There's a bunch of stuff I'm excited to migrate to

00:15:43 ◼   ► and to add and to, you know, that'll make my app better

00:15:47 ◼   ► and I am working on a big iOS 13, you know,

00:15:50 ◼   ► UI rearrangement and everything but it's not urgent

00:15:54 ◼   ► and so it's not gonna come soon.

00:15:56 ◼   ► It's not gonna come like on day one.

00:15:58 ◼   ► I'm not gonna do the thing I usually do

00:15:59 ◼   ► where I drop support for the old OS basically

00:16:01 ◼   ► in the first week of the new moon coming out

00:16:04 ◼   ► 'cause it's basically not ready yet.

00:16:06 ◼   ► I don't have time and I haven't had the chance to finish it

00:16:09 ◼   ► and it's too big of a job.

00:16:10 ◼   ► So instead what I've been doing is working on stuff

00:16:14 ◼   ► in the iOS 12 branch that doesn't require 13.

00:16:16 ◼   ► So underlying changes, code, you know,

00:16:19 ◼   ► like under like, you know, model level changes,

00:16:21 ◼   ► audio processing type changes,

00:16:22 ◼   ► anything that doesn't require new APIs for 13,

00:16:26 ◼   ► I'm doing on my master branch and then, you know,

00:16:29 ◼   ► every few weeks like pulling it and merging it

00:16:31 ◼   ► into my iOS 13 branch and then I have a second branch

00:16:35 ◼   ► off of the iOS 13 one for three column view

00:16:38 ◼   ► 'cause three column view breaks everything in the app.

00:16:40 ◼   ► So that one is like the iOS 13 build is kind of shippable.

00:16:44 ◼   ► The three column view branch which is branched

00:16:47 ◼   ► off the 13 branch is not at all shippable yet.

00:16:51 ◼   ► I can't even use it on my own phone yet, it's so broken.

00:16:53 ◼   ► Like everything is broken.

00:16:55 ◼   ► So I have this summer been doing a heck of a lot more

00:16:58 ◼   ► in the master branch while leaving the beta branch

00:17:02 ◼   ► as like my side project which is totally the opposite

00:17:05 ◼   ► of how you have usually done it.

00:17:07 ◼   ► But I do think there's a larger lesson here

00:17:10 ◼   ► which I'll get to in a moment.

00:17:10 ◼   ► But first, we are brought to you this week by ZOJO.

00:17:14 ◼   ► X-O-J-O, ZOJO.

00:17:16 ◼   ► ZOJO is a cross platform development tool

00:17:18 ◼   ► for creating native apps for the desktop, mobile, web

00:17:21 ◼   ► and even Raspberry Pi.

00:17:23 ◼   ► ZOJO currently supports Mac OS, Windows, Linux, iOS

00:17:26 ◼   ► and Android's coming soon.

00:17:28 ◼   ► With ZOJO, you write just one version of your app,

00:17:30 ◼   ► say on the Mac, then you just literally check a check box

00:17:32 ◼   ► and you have a completely native Windows version as well.

00:17:35 ◼   ► ZOJO uses native controls so your app looks at home

00:17:38 ◼   ► on every platform and you'll be able to build apps

00:17:40 ◼   ► 10 times faster which will save you time and money.

00:17:43 ◼   ► ZOJO is great for everyone, from newbies

00:17:45 ◼   ► to professional developers alike.

00:17:47 ◼   ► It's currently used by over 300,000 developers worldwide

00:17:51 ◼   ► from students all the way up to Fortune 500 companies.

00:17:54 ◼   ► Go take a look at their site and you can see

00:17:56 ◼   ► just how many companies you know use ZOJO.

00:17:59 ◼   ► It's free to use and then licenses are required

00:18:01 ◼   ► to build standalone apps.

00:18:03 ◼   ► To learn more, go to ZOJO.com/Radar.

00:18:06 ◼   ► That's X-O-J-O dot com slash radar

00:18:10 ◼   ► and you can get 20% off any license with the code radar.

00:18:13 ◼   ► Thank you so much to ZOJO for the support of this show

00:18:16 ◼   ► and Relay FM.

00:18:18 ◼   ► So I think one of the big themes that,

00:18:21 ◼   ► covering both testing which I also use but extremely little,

00:18:24 ◼   ► like I have a test suite for the FC model database layer

00:18:29 ◼   ► of my app which by the way is currently broken,

00:18:31 ◼   ► like it doesn't even build.

00:18:33 ◼   ► - Perfect.

00:18:34 ◼   ► - And I shipped an FC model bug in my beta tree last week

00:18:38 ◼   ► or the week before.

00:18:39 ◼   ► I shipped a couple of builds that had a pretty significant

00:18:41 ◼   ► bug in FC model that caused really bad performance

00:18:45 ◼   ► and I didn't even run the tests.

00:18:47 ◼   ► I haven't run the tests in months which is why

00:18:49 ◼   ► the build is broken.

00:18:50 ◼   ► 'Cause like certain things changed and the test suite

00:18:54 ◼   ► build broke and I didn't notice.

00:18:55 ◼   ► So I'm not a good tester and you aren't a very good

00:18:58 ◼   ► version controller and I think this leads to a larger issue,

00:19:04 ◼   ► or a larger I guess lesson or truth to this which is that

00:19:08 ◼   ► many of these tools, you mentioned continuous integration,

00:19:12 ◼   ► even version control to some degree, I do think all indies

00:19:17 ◼   ► should be using version control but you don't need to be

00:19:19 ◼   ► doing a lot of particularly fancy stuff with it.

00:19:21 ◼   ► And certainly testing I think would be in this category

00:19:25 ◼   ► as well.

00:19:27 ◼   ► These are tools that we have in the industry that

00:19:32 ◼   ► are kind of optional for indie developers because they're

00:19:35 ◼   ► not really made for us.

00:19:37 ◼   ► They isn't to say they can't help us but that they are

00:19:41 ◼   ► really much more necessary when you have a team

00:19:46 ◼   ► of developers.

00:19:47 ◼   ► When you have multiple people working on the same code base,

00:19:49 ◼   ► people at different skill levels working on different

00:19:52 ◼   ► components, maybe, and especially as your team gets larger,

00:19:56 ◼   ► these things become more and more necessary and more

00:19:58 ◼   ► and more beneficial.

00:20:00 ◼   ► But when you're just one person, a lot of these advanced

00:20:03 ◼   ► tools don't have that much bang for the buck for you.

00:20:08 ◼   ► And that isn't to say, again, this isn't to say you can't

00:20:10 ◼   ► benefit at all from them.

00:20:12 ◼   ► You very much can benefit from all these things.

00:20:14 ◼   ► Using advanced version control stuff, using automated

00:20:17 ◼   ► testing and test-driven development, anybody, one person,

00:20:22 ◼   ► up to 1,000 people can benefit from this.

00:20:25 ◼   ► However, I think the math changes of what's worth it or not

00:20:28 ◼   ► and to what degree you need to do this.

00:20:31 ◼   ► How deeply do you need to run these tests?

00:20:34 ◼   ► How advanced and how diligent do you have to be with your

00:20:37 ◼   ► use of branches and different commit styles and commit

00:20:40 ◼   ► messages and version control?

00:20:41 ◼   ► When you're in India, it gives you not only the freedom

00:20:47 ◼   ► to tone some of that down, depending on your preferences

00:20:50 ◼   ► and your needs, but also, I think you have kind of an

00:20:54 ◼   ► obligation to question a lot of this stuff and to question

00:20:58 ◼   ► how far you need to go with it as an indie, because you

00:21:02 ◼   ► don't have time to do it all.

00:21:04 ◼   ► Time is incredibly precious to indie developers.

00:21:08 ◼   ► It is by far our most limiting resource.

00:21:10 ◼   ► And if something's gonna cost a ton of time to improve

00:21:15 ◼   ► your code quality by 5%, that might not be worth it.

00:21:19 ◼   ► So you have to kind of find that balance for yourself.

00:21:21 ◼   ► Like which of these various advanced tools are actually

00:21:23 ◼   ► worth it for you?

00:21:24 ◼   ► - And I think too, there's a little bit of the time,

00:21:27 ◼   ► but I think honestly, the thing that I find more important

00:21:31 ◼   ► is motivation and fluidity, where there are certain things

00:21:36 ◼   ► that you could say that you should be doing because of

00:21:44 ◼   ► software engineering or just good best practice.

00:21:48 ◼   ► You're setting yourself up for more success in the future.

00:21:51 ◼   ► You're putting yourself into a good position.

00:21:54 ◼   ► Those are all true.

00:21:56 ◼   ► But any time that my tooling or my process is getting

00:22:01 ◼   ► in the way of my creation, that is like, I will fight that,

00:22:06 ◼   ► I will drop that, it will hurt my motivation,

00:22:08 ◼   ► whatever it is.

00:22:09 ◼   ► I mean, it is something that I think is, at least for me,

00:22:12 ◼   ► is just, it's far better for me to be excited and just

00:22:17 ◼   ► cranking away and making stuff and getting it out and

00:22:23 ◼   ► being thorough, but in ways that are not cumbersome, maybe.

00:22:28 ◼   ► And so many of these aspects of tooling or around testing

00:22:32 ◼   ► or version control or whatever, just sort of get in the way.

00:22:35 ◼   ► And I like being lightweight with this stuff.

00:22:39 ◼   ► And as much as there have been times that it comes back

00:22:42 ◼   ► to bite me, it has come back to bite me way fewer times

00:22:46 ◼   ► than you would think.

00:22:47 ◼   ► And having done this for hundreds of different releases

00:22:52 ◼   ► over the years, if you are, the testing that's really

00:22:55 ◼   ► important is getting it on devices and using it and playing

00:22:59 ◼   ► with it and making sure that you really have an understanding

00:23:03 ◼   ► of how the app is going to work and that you put it through

00:23:06 ◼   ► the use cases and the experience.

00:23:09 ◼   ► And the reality is that too, that kind of testing also,

00:23:13 ◼   ► if you put yourself in that position, is you're exposing

00:23:16 ◼   ► yourself to different kinds of problems, more qualitative

00:23:20 ◼   ► problems rather than just quantitative problems.

00:23:22 ◼   ► And that's something that is also very important, to be

00:23:25 ◼   ► like, man, when I run this on this whole device,

00:23:27 ◼   ► it's really slow.

00:23:29 ◼   ► I mean, in some ways, you can sort of get that from a test.

00:23:31 ◼   ► But having a number that says, running the test on this

00:23:34 ◼   ► device, your test suite takes 16 seconds to complete rather

00:23:38 ◼   ► than 13 seconds to complete, that may not be nearly as

00:23:43 ◼   ► impactful on you or as important to you.

00:23:46 ◼   ► And so that's just something else that I keep in mind.

00:23:48 ◼   ► And I think especially, I like kind of, I don't know, maybe

00:23:51 ◼   ► like over the summer, everything's just kind of feels a

00:23:54 ◼   ► little bit more loosey goosey for me.

00:23:56 ◼   ► But it's a time of year where I enjoy just kind of trying

00:24:00 ◼   ► things out and being much less structured.

00:24:04 ◼   ► It kind of makes me laugh, but I feel like at the end of the

00:24:07 ◼   ► summer, the rightmost page of my phone is full of apps that

00:24:12 ◼   ► are just like the white icon with the little icon grid in

00:24:17 ◼   ► it.

00:24:18 ◼   ► Like, not even joking, I think I have probably, let's see,

00:24:23 ◼   ► one, two, three, four, five, six, seven, eight, I have 24

00:24:27 ◼   ► of those.

00:24:27 ◼   ► (laughing)

00:24:28 ◼   ► Like an entire--

00:24:30 ◼   ► - That's awesome.

00:24:31 ◼   ► - It's like an entire page, and a few more of apps.

00:24:35 ◼   ► And I like this time of year where it's like, ah, I wonder,

00:24:38 ◼   ► it's like, hey, this is a new interesting API.

00:24:40 ◼   ► Like, let me just make an app.

00:24:42 ◼   ► And I'm not doing version control, I'm not thinking about

00:24:44 ◼   ► release or anything kind of structured for it.

00:24:47 ◼   ► It's just like Xcode, file, new project, give it a go, and

00:24:52 ◼   ► like 99% of that will just get thrown away.

00:24:55 ◼   ► But what is also kind of surprising and kind of nice is

00:24:59 ◼   ► more often than not, there'll be one function from that

00:25:02 ◼   ► little experiment, that little project, that little thing I

00:25:06 ◼   ► did once on a hot afternoon in the summer when I was feeling

00:25:09 ◼   ► bored.

00:25:10 ◼   ► We'll come back and it'll be useful.

00:25:13 ◼   ► Or later in the time it'll be like, oh, I wonder, I need to

00:25:18 ◼   ► use this API, how does it work?

00:25:21 ◼   ► Or like, I have in my mind, oh man, that API is full of

00:25:24 ◼   ► dragons and is going to bite my head off, and I'm not even

00:25:26 ◼   ► going to go near it.

00:25:28 ◼   ► It's useful, and some of that is just about being loose,

00:25:33 ◼   ► fast and loose with the stuff that you can be, and then just

00:25:36 ◼   ► being conscious and intentional with stuff that is probably

00:25:39 ◼   ► best not to be.

00:25:40 ◼   ► And I think as indies, we have to think about the entire

00:25:44 ◼   ► business, not just the code.

00:25:47 ◼   ► And a lot of this, I think your instinct to avoid and get

00:25:52 ◼   ► rid of things that slow you down from experimentation is

00:25:55 ◼   ► very good for this business because you can have the most

00:25:59 ◼   ► battle hardened, rock hard, 100% test suite coverage, you

00:26:04 ◼   ► can have the best app in code quality in your category, and

00:26:08 ◼   ► then someone else can come with a really crappy one and

00:26:10 ◼   ► take a bunch of market share from you because they can move

00:26:12 ◼   ► faster than you, or they're doing features that you didn't

00:26:14 ◼   ► do, or they're undercutting you on price, or whatever else.

00:26:17 ◼   ► The market does not reward code quality beyond a certain

00:26:21 ◼   ► level.

00:26:22 ◼   ► We're not launching the space shuttle here, we're making

00:26:24 ◼   ► apps for phones for the most part that aren't very important

00:26:28 ◼   ► that no one's going to die or get hurt if our app crashes,

00:26:31 ◼   ► or behaves slightly weirdly.

00:26:32 ◼   ► If you're in one of those fields where that's not the case,

00:26:35 ◼   ► please don't listen to any of this advice.

00:26:37 ◼   ► But most of us are doing things that that level of code

00:26:42 ◼   ► quality mostly just hinders us, and it's really hard to

00:26:47 ◼   ► accept as a developer, there's a bug here, I know there's a

00:26:50 ◼   ► bug here, and I have to ship this version anyway because I'm

00:26:52 ◼   ► going to miss the deadline if I don't, or whatever.

00:26:54 ◼   ► But again, it's about finding balance.

00:26:58 ◼   ► You can't have massive top 100% code quality and also still

00:27:03 ◼   ► be nimble and be making an app that has good features and is

00:27:08 ◼   ► competitive in your category if you're one person.

00:27:10 ◼   ► You just can't, you're only one person.

00:27:12 ◼   ► And so you have to kind of choose areas in which to take

00:27:14 ◼   ► shortcuts that hopefully won't impact things too badly and

00:27:18 ◼   ► will hopefully keep you nimble and keep you competitive.

00:27:20 ◼   ► And you have to think about the whole business holistically,

00:27:23 ◼   ► not just the code quality itself.

00:27:27 ◼   ► - Yeah, and I think too, there's an aspect too of making

00:27:29 ◼   ► sure that you understand why you're doing something that

00:27:34 ◼   ► you're doing.

00:27:35 ◼   ► Like, there's the reasons why many organizations have robust

00:27:40 ◼   ► processes and like sophisticated version control or build or

00:27:45 ◼   ► continuous integration.

00:27:46 ◼   ► The reason why they do that may be to catch problems that

00:27:50 ◼   ► won't exist in your case.

00:27:52 ◼   ► Like some of the continuous integration stuff is about

00:27:54 ◼   ► making sure that merge conflicts don't mess up the builds.

00:27:57 ◼   ► Like you're not gonna have a lot of merge conflicts if you're

00:28:00 ◼   ► the only person working on the code.

00:28:02 ◼   ► It's not like someone else has been working on it.

00:28:03 ◼   ► Like these are, there's a reason why it exists and that may

00:28:06 ◼   ► not be something that actually applies to you.

00:28:08 ◼   ► And so like doing something blindly is never a good idea.

00:28:11 ◼   ► So it's also like, I think just being thoughtful and saying,

00:28:14 ◼   ► is this actually useful?

00:28:15 ◼   ► Is this making my product better?

00:28:17 ◼   ► Is this improving my product in a way that my customers are

00:28:19 ◼   ► going to appreciate and enjoy?

00:28:21 ◼   ► And is it motivating me?

00:28:22 ◼   ► Is it keeping me excited?

00:28:24 ◼   ► Is it keeping me moving and like doing all the things that

00:28:27 ◼   ► are actually driving the product forward?

00:28:30 ◼   ► And if it is, great, do it.

00:28:31 ◼   ► Otherwise, like drop it and it's like spending that time

00:28:35 ◼   ► enjoying the summer instead.

00:28:37 ◼   ► - And more importantly than a lot of these factors,

00:28:40 ◼   ► you have to consider is it worth it?

00:28:41 ◼   ► Because all these things have costs.

00:28:42 ◼   ► They all have costs.

00:28:44 ◼   ► You know, you can point to any of these things and say,

00:28:46 ◼   ► well, if you have, if you do this kind of practice or this

00:28:49 ◼   ► kind of technique, you'll save yourself from problems X, Y,

00:28:51 ◼   ► and Z and that's invaluable.

00:28:53 ◼   ► But nope, it has a value and all these things have costs.

00:28:56 ◼   ► And you have to weigh whether those costs are worth it.

00:28:59 ◼   ► A lot of times we get so obsessed with the cool part of what

00:29:02 ◼   ► these tools and techniques can do that we ignore the costs.

00:29:05 ◼   ► We ignore like, wow, that took me eight hours to set up

00:29:07 ◼   ► or something like you ignore those costs.

00:29:10 ◼   ► But these all have costs and you could be doing other things

00:29:13 ◼   ► with that time instead, possibly even nothing and taking a

00:29:16 ◼   ► vacation and you have to really weigh what that's worth.

00:29:18 ◼   ► Companies are really bad at that.

00:29:20 ◼   ► Companies waste a lot of money on things they might not,

00:29:23 ◼   ► they might not need because they're afraid of different

00:29:24 ◼   ► factors and everything.

00:29:25 ◼   ► But you as an indie have to be more conscious of time cost

00:29:30 ◼   ► of what these things take.

00:29:31 ◼   ► - Yeah.

00:29:32 ◼   ► - Anyway, this, here we go proves that we can talk about

00:29:34 ◼   ► anything for a half hour.

00:29:35 ◼   ► Thank you so much for listening everybody and we'll talk to

00:29:38 ◼   ► you in two weeks, hopefully with a topic that time.

00:29:41 ◼   ► - Yeah, bye.

00:29:41 ◼   ► Bye.

00:29:42 ◼   ► [BLANK_AUDIO]