What does it take to track detailed analytics and errors from literally thousands of web
applications at once? Could you build such a system entirely in Python? Answer is yes.
And we'll hear from Ron Cohen from Opbeat about how they do it for Django, Flask,
and even Node.js apps. This is episode 43, recorded January 13th, 2016.
Welcome to Talk Python to Me, a weekly podcast on Python, the language, the libraries, the
ecosystem, and the personalities. This is your host, Michael Kennedy. Follow me on Twitter,
where I'm @mkennedy. Keep up with the show and listen to past episodes at talkpython.fm,
and follow the show on Twitter via at Talk Python. This episode is brought to you by Hired and SnapCI.
Thank them for supporting the show on Twitter via at Hired underscore HQ and at SnapCI.
Hey, everyone. Do you remember that t-shirt Kickstarter I did last summer to create a cool
Talk Python to Me podcast t-shirt? It was super successful reaching its funding goal within
just two hours. Well, the shirt is back. I've worked with our friends at pythongear.com to make
the shirt available on demand for just $25. Visit talkpython.fm/shirt and get yourself one
while they're hot. The proceeds support the show and the shirt helps spread the word about the podcast.
Now let's get right to the conversation with Ron Cohen, the CTO and co-founder at OpBeat.
Ron, welcome to the show.
Thank you. Thank you so much, Michael.
You're welcome. I'm a big fan of OpBeat, and I know you guys do a ton of stuff with Python.
So it's going to be a really interesting conversation. And before we get into all that,
though, as usual, how did you get started in programming in Python?
I got started programming initially because one of my friends borrowed some books at the library.
This is many, many years ago. And it was about the programming language,
basic, as I'm sure a lot of people got started with basic. I immediately found it very intriguing to be
able to tell a computer what to do and sort of interact with it. And my friend quickly lost interest,
but I sort of kept going. And my dad was actually also programming and working as a programmer.
So a lot of people think I got into programming because of him, but it turns out it actually was
in spite of him also programming. And Python, the way I got started with Python was another buddy of mine
who really thought I should take a look at this Django thing, this thing called Django.
Because at the time I was working as a consultant doing web applications,
and I had done web applications in Rails and PHP and all sorts of different languages and framework.
But he really insisted that I try out Django. And then I had to learn Python to actually
to work with Django. And I've pretty much stuck with it ever since.
Oh, that's excellent. When was that? What time? What year?
Oh, good question. I think it's like three or four years ago.
Yeah, Django is excellent. Python is just such a fun programming language to work with.
It's such a fun ecosystem. It's hard to not love it.
Yeah, it really is. And so the thing I like about it is that it's so explicit.
There's no surprises.
Yeah, there's very few gotchas. You often hear about JavaScript gotchas
and all the things you've got to be careful of. You don't typically hear about the Python gotchas.
I love that.
Yeah, JavaScript is interesting.
Yes, it is. I'll ask you more about that later, actually.
You like Python so much, you started a company called Opby, right?
Yeah, yeah, exactly. So I helped start Opby with a friend.
In the beginning, it was just me and him. He's called Rasmus.
And we had been working as consultants building web applications for a while together.
And every time we sort of built something, we found that we were also the people that ended up running it.
So maintaining it and making sure that it actually worked.
What we found there is that all the tools were sort of targeted people who were technical ops people.
So ops people, basically.
Developers just really think in a different way than ops people do.
And they also need to know about different data.
So we thought we'd build a product that helps developers operate their applications that they build that was targeted to developers directly.
And that's how we sort of got started with Opby.
At the time, I was really into Python.
So, and I mean, I still am, obviously.
So we started building in Django and Python.
And today, it's pretty much all Python.
That's awesome.
So in sort of the whole back end of what you guys have going there, not just what plugs into the app, it's all Python, huh?
Mostly Python, let's say.
Yes.
We started now doing, we started working on support for Node.
So Node.js, because that's also a big opportunity for us.
That's going to be really interesting to see how that goes.
Yeah.
I just saw today that you guys have a beta program that people can go sign up for.
So that's cool.
So let's talk about monitoring apps in general.
You said there's sort of the infrastructure side of folks, and they have one set of things they want to know about.
We've got the developers.
And then also we've got this, you know, this growing sort of DevOps continuous delivery set of people that maybe have kind of a mix of those things.
But what do people want to know about in their apps?
Like what kinds of things can be tracked in applications like Opby, things like that?
How does that all work?
Right.
So you're absolutely right.
There are different sort of disciplines within this DevOps ideology or terminology or whatever you want to call it.
So if we start with monitoring, that's really sort of focused on delivering actionable metrics for developers.
And for us, that means that all the data that we give you, it has to sort of relate to your application.
So it has to be something that you can use to improve the performance of your application.
That means we don't deal with sort of the machines that your application runs on very much more sort of the code that you've written.
And that's something we hear is really attractive to developers because that's sort of also their angle of attack, if you will.
Basically, it all depends on the code and deals with the code.
And things like response times for an application, that's, of course, really interesting.
And then also sort of delivering it to developers in a way that they are used to think about stuff.
So some tools deal with something called aptics, which isn't really a metric that people are very used to working with.
It's probably something that ops people are more used to, or even just business people who need to deliver some kind of SLA.
Developers are more familiar with averages and percentiles.
So that's, for example, a choice we've picked instead of aptics.
Then there's error logging.
So there's a lot of ways that you can be logging errors.
The most basic thing is write them to a file.
A lot of people do that, and then they ship those lines in the file off to some service.
And then they search through the lines of the files to see what kind of errors they had.
And that's also, I feel like, something that caters to ops people more than developers.
Developers are used to dealing with code.
So when an error happens, they would really like to see a proper stack trace.
They'd really like to get an email or get notified on a mobile phone that something is now broken.
They don't want to just tail some log and sit there and watch it go by.
They want detailed stuff that they can go back and actually track down the bug with.
Not just knowing there's a problem, but all the details, right?
Which maybe don't necessarily fit on a line in a log file.
Exactly, exactly.
And when you have the details sort of in a structured way, there's a lot of stuff you can do to make it more useful, more actionable.
Yeah.
I guess you could say, like, what are the most common exception types?
How many exceptions do we have per hour?
Right?
Yeah.
Whose check-in has caused the most exception?
Yeah.
And we actually do that.
Or we do something called automatic assignments.
So, based on who checked in the code, we'll automatically assign that error to the person who checked in the code.
That's awesome.
Thanks.
That's something you can only do if you have the data in a structured way.
Yeah.
Just one example.
Yeah, yeah.
I love the blame feature of source control.
You can say, all right, this looks ridiculous.
Who wrote this?
And that's kind of the error equivalent of blame, right?
Yeah.
And it's, you know, it's not a good way to think about it, blame.
But it's also not very effective for you to sit and work on something that someone else on your team knows much more about.
Yeah, well, there's the negative way of looking at, like, blame, right?
Whose fault is this?
But then there's also the sort of the positive perspective of, like, whoever wrote that code and probably just checked it in, they're more likely to be able to quickly fix it, quickly go, oh, geez, yes, I understand.
Let me do this, da-da-da-da-da, right?
If you just give it to somebody out of the blue, go, here's a random problem with some app.
You probably didn't write it, but fix it, right?
That's much harder to get it fixed quickly.
Yeah, absolutely.
Absolutely.
It's also about accountability in some sense.
We can talk about it a little bit later.
But in my experience, good developers, they like to be held accountable.
So they like to know when they actually made a mistake.
And this is sort of a way to complete the circle, if you will, after you write something.
You will also be assigned to the errors that your code caused.
Yeah, I think, especially when you're learning the program, when you're a fairly junior developer,
the whole error handling, dealing with malformed data, unexpected things, and so on, that's much harder to get your head around.
It's much easier, I think, to write the code so it's supposed to take this and it's supposed to do these things and it's done, right?
Just like the happy path, if you will.
But knowing to be aware of all these other errors, right?
That's something that takes more experience, I think.
And so if you can help catch those sooner and maybe learn those lessons sooner, that's also good.
Yeah, absolutely.
Nice.
So you talked a little bit about performance and you talked about errors.
You guys also talk about, like, deployment and workflow.
What's the story of that?
Right.
Again, coming back to the DevOps paradigm, if you will, what we found is that developers now are more and more empowered to deploy their own code whenever they feel like it's finished.
And whenever the CI tests pass, it's usually the case nowadays that developers actually have the power to deploy their code.
Now, that's really cool.
But it also means that it can get pretty difficult to figure out what was actually deployed at what time.
Because you probably used to have an ops department that would make a little note in a changelog somewhere to sort of keep track of what was deployed.
But developers don't really do that.
So we help them do that by what we call release tracking, which is basically a list of releases.
And each item in the list will contain the commits that went into a specific release.
That makes it really easy for you to go back and see exactly what you deployed at what time.
Yeah.
So maybe you can link those back to a series of GitHub issues that have been closed or something like that, right?
Yeah, exactly.
Or errors that started happening after a specific release, etc.
Yeah, it's another sort of case where the tools and the sort of workflows that you used to have don't really fit anymore.
And that's why we did this release tracking.
Yeah, that's really cool.
I mean, it definitely ties together with continuous integration and continuous delivery and services that companies like SnapCI and those guys build, right?
To sort of do the checking before it goes out.
But you guys are kind of on the other end, right?
Once it hits production, if something happens, you can sort of say, after this release, these errors started happening.
Is that right?
Yeah, yeah, exactly.
And CI is obviously still a really important part of the modern workflow.
And yeah, it's definitely not a replacement.
Yeah, absolutely.
But, you know, the thing is, there's the unit test you write and the scenarios you test for and look for.
And then there's the real world, right?
Yeah, absolutely.
You know, no matter how good your CI system is or your tests are, chances are on some major application, there's something happening that's going to happen that you just didn't account for.
Like, why are there browsers on my page that have no user agent?
I didn't plan for this, right?
You know, just weird stuff like that, right?
This episode is brought to you by Hired.
Hired is a two-sided, curated marketplace that connects the world's knowledge workers to the best opportunities.
Each offer you receive has salary and equity presented right up front, and you can view the offers to accept or reject them before you even talk to the company.
Typically, candidates receive five or more offers within the first week, and there are no obligations, ever.
Sounds awesome, doesn't it?
Well, did I mention the signing bonus?
Everyone who accepts a job from Hired gets a $1,000 signing bonus.
And as Talk Python listeners, it gets way sweeter.
Use the link Hired.com slash Talk Python to me, and Hired will double the signing bonus to $2,000.
Opportunity's knocking.
Visit Hired.com slash Talk Python to me and answer the call.
Yeah, absolutely.
And it turns out that users are really creative in what they will enter into a form, and you basically have no chance to guess what all the different scenarios are going to be.
Yeah, yeah, absolutely.
So right now you guys support Django, and that's where you started.
And recently you added Flask support, and you also are about to add node support, or you're beta testing it.
What about other apps?
Like a lot of the apps that I work on, the web apps, are pyramid apps.
Is there a way to add tracking to apps that are not one of those three?
Yes, there is, actually.
And we've not been very good at documenting this, but the Upbeat module has a very simple API, and it comes down to calling begin transaction whenever you sort of start a new request or a background job starts.
And then you call end transaction whenever you've sent back the response or your background task has finished.
And the Upbeat module will automatically pick up all the information it needs in between those.
That's performance metrics, performance monitoring.
And error logging, usually there's a way to look into the framework's sort of unhandled exception signal or something like that.
So it should definitely be doable.
We just haven't really had the time to look at it yet.
Okay, that's interesting.
So if I was able to sort of trigger like a bit, like do a begin transaction and an end transaction, all the calls I'm making, say, to SQLAlchemy or out to other web services, those would get tracked?
Actually, what you need to do is just call begin transaction whenever your request starts.
And we already instrument most of the modules you use, I hope.
So that data should automatically show up, actually.
What you need, yeah, the only thing you need to do is call begin transaction when the request starts and then end transaction when the request ends, the web request, let's say.
Oh, sweet.
Well, I may have to go play with this after.
Cool.
Let me know how it goes.
Yeah, very cool.
So what's the craziest sort of monitoring example you've seen?
Like there's got to be some company or some piece of software that's just done something way crazier than you've expected.
That's a really good question.
Well, I can tell you the first time your main database server just drops off the face of the net.
It's a very unpleasant experience.
But that was a bit of a rough night.
We had to fail over to the replica database and the site was down while we did it.
So we did it pretty quickly.
I would say it was like 15 minutes, but it was still not a very nice experience.
Yeah, I guess so.
Because, I mean, you guys are running real-time data collection from many potentially popular apps.
And so you're sort of, you guys must have a lot of load, a lot of requests, huh?
Yeah, yeah.
We have quite a lot of load, quite a lot of requests.
If we're down, then people will get us a little notification in their log whenever they try to send something to us.
And that's really not cool, right?
You want your monitoring service to be up all the time.
Otherwise, it's sort of useless.
So we spent a lot of time trying to make sure that we can't go down.
And so what we recently did was we changed it so that we should still be able to receive data, even if the main database server is down.
So that data is just going to keep being accepted by us.
And then whenever the server is back up, it'll start processing the data.
What infrastructure are you guys running on?
Is it like Amazon Web Services or something else?
Yeah.
Yeah, so it's all Amazon Web Services.
We've set it up ourselves.
So it runs on EC2.
We don't use too many of the sort of Amazon services on top of it.
We use a bit of S3, but mostly EC2.
Yeah, EC2, S3.
Those are the main ones, right?
Yeah, exactly.
You talked about performance and collecting data, even if it can't necessarily be processed.
And one of the really nice ways to do that is to add some sort of queue, asynchronous queuing mechanism to the whole process, right?
Yeah, exactly.
And we do that a lot.
So whenever some data comes in, it immediately gets put into a queue.
We use RabbitMQ, which is a very, very powerful software.
That gives us a lot of freedom in scaling out, handling failures, et cetera.
Right, because it's much easier to keep a queue alive than maybe a complex database where the schema could change and it can no longer insert into it or something like this, right?
Yeah, exactly.
Maybe talk me through what pieces are involved.
What does it look like from some web app external to you guys sending some piece of data until it actually gets totally stored in some database?
Right.
So we have a separate service called the intake, which is responsible for basically accepting data and put it into a queue.
It's also what does authentication and authorization of the data.
So whenever data comes in, we need to make sure that it has the right tokens, et cetera.
We also rate limit you there.
So if you send us a lot of data, we will rate limit you right there.
We need to validate that the structure of the data is actually correct.
So we also do that.
And then we put it into a queue.
So that service is very sort of simple in the sense that it just needs to accept the data and put it into a queue.
And that makes it easier for us to scale up when we have a lot of data coming in.
Yeah, but it's almost stateless, right?
Other than knowing the authorization part, it's like entirely stateless, right?
Yeah, exactly, exactly.
So a lot of the, you know, we can cache the authentication stuff really heavily.
And it's also a very resilient interface of failures because it's read-only from the database, like the authentication stuff.
It just needs to be able to put data into a queue.
Yeah, excellent.
So then there's something else that gets the data back out and really does the processing, right?
Right.
So we have a separate service that pulls the data out and then processes it.
And that's also very convenient for us because it means that we can scale that out very easily.
We have more freedom in sort of, let's say, we need to do some maintenance.
We can stop that for a short period of time and then keep going.
And things will just be in the queue for waiting for us to process them.
Yeah, I think queues are somewhat underused.
They're so easy to use, and yet they provide so much architectural flexibility and response time flexibility and so on.
And even as you say, sort of like a deployment infrastructure management perspective, like long as you don't read things offline until the queues can't take anymore, then you're kind of golden, right?
Yeah, yeah.
We do have some requirements for processing time.
So we can't leave stuff around forever, but it does give us a lot of flexibility in switching out things while everything is running.
So that's great.
And I agree on the point that queues are undervalued and also probably not that well understood in the best majority of developers.
There's also some, as you mentioned, architectural benefits.
It sort of forces you to decouple a lot of systems, which is always a good thing.
Yeah, you know, there's a lot of talk about microservices and building more smaller pieces of software and putting a queue in between those two pieces makes it real easy rather than having a monolithic thing that does all the intake, all the processing, all the reporting, and on and on and on, right?
Yeah, absolutely.
And there's also a pattern emerging where people use the queue as a sort of bus to talk between the services.
So it basically becomes a sort of communication medium instead of, for example, using HTTP, people will put a request in the queue and then expect a response on some other queue.
And that's also quite useful because it gives you some additional architectural advantages when it comes to timeouts and things like these.
Yeah, that's really cool.
All right, so I have a big question for you.
Hit me.
Python 2 or Python 3?
Python 3 for the sake of progress.
Oh, beautiful, beautiful.
I know a lot of people are on Python 2, but any chance we can get to kind of move forward, we should take that chance, right?
Yeah, I agree.
It's a bit of a cost that we have to pay now, sort of upfront, but it's the right thing to do, in my opinion.
Yeah, excellent.
I agree.
A lot of the systems that people are writing that are kind of in the realm of what you guys are doing, they're maybe choosing languages like Go and Rust.
Do you know sort of what the advantages of those are, like what the disadvantages are?
Have you guys considered those?
Not that I'm necessarily encouraging you to do so, but I know a lot of people are thinking about that.
Yeah.
So I've written some Go and a little bit of Rust, and I think they're really interesting.
I think what still is very clear to me is that Python helps me get things done very quickly and with very little code in a very robust way.
If we start with Go, for example, I think Go is mostly interesting in the way that concurrency works in Go.
I think the main reason why you would write something in Go instead of Python is the concurrency primitives that exist in Go.
So Python has a really sad concurrency story, in my opinion.
And usually, like if you do Django, it's not a big problem.
But as soon as you have to write a service that talks to the outside world and you want to talk to many different web services at the same time or something like that, then that becomes kind of difficult in Python.
And it basically comes down to the event loop, in my opinion.
Go is sort of built on top of an event loop that is seamless to you when you program.
Getting an event loop into Python usually involves some kind of monkey patching, for example, with g event or some really sort of strange, at least if you're coming from the Python world, some strange modifications that you must make to your application to get this kind of event loop concurrency.
And then there's Rust, which I think is also super interesting.
It has a much more interesting type system than Go.
But at the same time, the Rust feels more like a replacement for C++.
So some of the things that you will typically use Python for, it also makes sense to use Go for.
But I would say Rust is in a different category.
And I feel like a lot of people are comparing.
So there was recently a lot of people talking about if they should use Go or Rust.
But in my opinion, they are applicable to different use cases.
So Rust is more low level.
You have to deal with memory management yourself.
And that's important.
But it's sort of other sorts of applications that you write in Rust than it is Go and Python.
I see it almost more as a replacement for things like, I would have done this in C.
So now I'll do it in one of these languages.
But that could just be my lack of experience with them, right?
No, I think you're right.
Especially when it comes to Rust.
I think Go is somewhere in between.
It's aesthetically typed.
It feels a lot more high level, I would say, than C or Rust.
SnapCI for sponsoring this episode by trying them for free at snap.ci.
simply do a get push and they auto detect and run all the necessary tests through their multi-stage
pipelines. Something fails, you can even debug it directly in the browser. With a one-click
deployment that you can do from your desk or from 30,000 feet in the air, Snap offers flexibility
and ease of mind. Imagine all the time you'll save. Thanks SnapCI for sponsoring this episode
by trying them for free at snap.ci slash talkpython.
So let's talk about shipping software a little bit more. Yes. You said you had some recommendations
for sort of how to make your team a high-performance shipping machine. What's the story there?
Right. My role here at Upbeat has transitioned from coding every day to more and more trying to get my
team to be efficient managing, if you will. And along that path, different things sort of became
clear. Yeah, there's some different things that you should be aware of, I think, when you are managing
a team of developers or even if you're just a single developer building applications, especially for
the web. That's sort of what we've been focusing on, building applications that live on the internet.
That's really interesting. You know, I think a lot of people who are working by themselves
don't necessarily adopt some of the sort of what you would think of as best practices and tooling that
maybe teams would automatically adopt. Things like continuous integration, things like, you know,
sometimes even source control. But, you know, things like application monitoring and so on.
So you think even if there's one person working on a project, maybe you should put this stuff in place?
Yeah, absolutely. Absolutely. Especially like things like CI. I think you should definitely
have CI even if you're just a one person team.
So if I have like my files on the hard drive and I just zip them up periodically and put a date on it,
that's probably not enough?
I've seen that by the way.
I've seen that before.
No, really, that's not. Okay. Well, let's talk about first source control.
Yeah. Oh, that's horrible.
It's been a few years, but still.
Right.
So maybe you could make it concrete. Like, what do you guys do to ship software like
at Opby to sort of push out new versions and so on?
Yeah. Good question.
So one of the things we really focus on is getting things shipped early in the sense that
whenever there's something that is an improvement to what we have today, we'll generally try to ship it.
And what typically happens when you are sitting and programming and working on some feature is that
you sort of got started on this feature and it's going well, but your feature relies on something else.
depends on some other code and you sort of take a peek into that code and it feels really sort of,
it has some of those bad code smells that we as developers are familiar with and are sort of trained to recognize.
So you consider whether you should just quickly refactor that other thing that your feature is going to depend on.
What usually ends up happening is that you end up actually spending time both working on your feature
and refactoring that other thing that you found.
And then that thing relies on some third thing and you think, oh, well, I made it.
I might as well just refactor that thing too.
And then it ends up being a huge release when you finally get it shipped.
And that's sort of a big red flag for us.
Big releases are a problem.
They're a problem for multiple reasons.
First of all, they are much more cumbersome to review.
So everything we do gets peer reviewed.
And if you have a big release, that just takes much more time.
And it's much harder to get an overview over the impact of this particular release when it's huge.
And it also takes much more time before your stuff actually comes out to the users.
The sad thing about that is that we know as developers that, you know,
you can think of a lot of scenarios on how you have some idea about how your users are going to use a specific feature.
And you obviously think that the feature is really valuable to them.
But it turns out that our assumptions are often wrong about this kind of stuff.
So getting new features into the hands of users is really important because then you will learn how they are actually going to use it.
It's really hard to predict what people will find valuable, what they won't.
Yeah, exactly.
Like you said, how they're going to use it.
Speed is an advantage in the software business, right?
Yeah.
Small releases actually give you a lot of speed, in my opinion.
There's also the things like when something breaks.
If you have just released a huge change, it's really difficult to figure out what part of that change actually made things break.
But if you're releasing small releases all the time, it's much, much easier to go back and see exactly what caused a specific problem.
So we're huge proponents of small incremental releases at Upbeat.
And it's something to reiterate on, sort of talk about often.
The other side of that story is if everything you are releasing is a small little feature or a small piece and something goes wrong, it's pretty painless to just say, whoops, we're just going to roll it back to the way it was before.
Yeah, yeah, exactly.
But if you've had to do some massive database migration to like roll out a huge new thing and then you're kind of stuck, right?
Not only is it speed going forward, it also enables you to go, oh, no, roll it back, roll it back.
Hopefully nobody saw that.
Yeah.
Another thing that is really useful when you're building applications is to make sure you try to break down silos.
For us, that means that getting something shipped is a sort of cross-discipline process.
We have a product designer that works with a visual designer that works with a developer and finally with marketing.
And that means everybody is sort of aligned on shipping this feature.
Of course, there's a lot of talk about DevOps, which one of the points there is that your operations people should be aligned or should have the same goals as developers.
And that makes for a much better process and a much nicer product in the end.
That's really interesting.
So, you know, I used to, I feel like teams used to be structured horizontally, like here's the data guys.
Here's the middle tier service guys.
Here's the front end people, right?
Yeah.
That doesn't seem like a great workflow.
So you're saying a vertical slice through that is a much better way to group people and features and work, right?
Yeah, exactly.
And even including the marketing people and designers and product designers in that slice so that you have like a wide range of capabilities on a specific team or aligned together to ship a feature.
My point was that, you know, people talk about DevOps, but really we should be talking about collaboration between all the sort of different roles or disciplines that are involved in shipping a feature.
So DevOps, the collaboration between ops and developers is just the very start.
You should have marketing and product design, et cetera, in there as well.
Yeah.
So you're proposing like a DevOps mark prod team.
So it's going to be a new password.
But I think you're right.
That makes a lot of sense.
And it's really easy as software people to forget once you write the software, unless you have a very established business,
or you're writing internal software.
That's only part of it, right?
You've got to have a marketing effort and a product development.
Like you said, it's a whole team effort and software is only part of it.
Yeah, exactly.
Another thing that's important for us when we ship code is that the person who wrote the code is also the person who actually presses the button to get that code into production.
That's something we've insisted on from the very beginning, because that means that if something breaks, that developer who wrote the code will be around to fix it.
So he didn't go home.
And the developer who actually presses the button knows exactly what code is going to go out.
And it's basically about accountability.
So you want to make sure that the developers that you're working with and that you also understand that if you've built something, so you've written some code, you're the person who ships it.
And then if it breaks, you're the person who fixes it.
That's something we've really sort of been adamant about from the very beginning.
And it seems to work very well.
Yeah, I think that's great advice.
You know, there's always on teams people who embrace things like continuous integration that you just have seen more, and there's people who embrace it, let's say, less.
But making everyone be actively part of the shipping puts the accountability on them, which means maybe they'll rely on the process a little more.
Maybe they will run those tests before they send it out, right?
Something like this.
Exactly, exactly.
Let me ask you a few more questions.
We'll kind of get into the end of the show here.
What's your favorite editor?
If you're going to write some Python code, what do you open up?
These days, it's actually mostly PyCharm.
I found it to be really useful, and it has a lot of interesting features.
It helps me find the stuff that I need very easily.
It's a bit heavy, but I still feel like the JetBrains people have spent a lot of time making it fast.
So I'm pretty happy with PyCharm.
Yeah, that's cool.
Like I've said a bunch of times on the show,
that's the one I use as well.
And like you said, it's a bit heavy.
But if you're willing to wait five seconds, the whole next few hours are a lot nicer.
So that's worth five seconds in my opinion.
That's awesome.
I agree.
And there's thousands and thousands of packages out there that you can use in Python.
What are some of the ones that maybe not everyone knows about that you're like, oh, this thing is awesome.
You should know about X.
Oh, good question.
Of course, I'm going to have to say the upbeat module.
But apart from that, some of the modules we've used that are really useful are, for example, something called dog opt, which is a way to...
It basically helps you write command line applications.
And it helps you parse command line arguments.
And the way it works is opposite of how all the other ones work.
So in here, you actually write your usage document.
So the stuff that comes out when you do dash H.
And then it'll parse that.
And from that, it'll know how to parse the arguments to the application.
So that's really useful, in my opinion.
The modules that come with Python, opt-parse, and arg-parse are really not very good, in my opinion.
Yeah, that's a really cool package.
I've heard of that one before.
And what surprised me was that there's actually a specification for the way that you write that help documentation that's, like, well-structured.
And so this thing just looks at that and builds the actual command line for you, right?
Oh, yeah.
Exactly.
Man, that's really awesome.
Yeah.
I think some other things that we're using is requests is always a good module.
Yeah.
I'm sure most people know that.
Request is amazing.
You can't get away without requests, right?
Right.
Exactly.
All right, Ron.
So how about a final call to action?
How do people get started with Upbeat?
What should they do?
It's really easy to get started with Upbeat.
You go to Upbeat.com and you sign up, create your first Django application or Flask application, and the instructions are right there.
It takes, like, five minutes to set up, probably.
And it's free to get started.
Everyone can go and check it out.
Please let us know if you run into any issues or get any feedback.
We're always trying to improve it.
So, yeah, looking forward to hearing the feedback.
All right, very cool.
Thanks for the look inside of what you guys are doing there.
There's a lot of cool stuff happening at Upbeat.
Thanks for having me, Michael.
Yeah, you bet.
Thanks for the advice on shipping software.
That's great.
Talk to you later.
Bye.
This has been another episode of Talk Python to Me.
Today's guest was Ron Cohen, and this episode has been sponsored by Hired and SnapCI.
Thank you guys for supporting the show.
Hired wants to help you find your next big thing.
Visit Hired.com slash Talk Python to me to get five or more offers with salary and equity
presented right up front and a special listener signing bonus of $2,000.
SnapCI is modern, continuous integration and delivery.
Build, test, and deploy your code directly from GitHub, all in your browser with debugging,
Docker, and parallelism included.
Try them for free at snap.ci slash Talk Python.
You can find the links from today's show at talkpython.fm/episodes slash show slash 43.
Be sure to subscribe to the show.
Open your favorite podcatcher and search for Python.
We should be right at the top.
You can also find the iTunes and direct RSS feeds in the footer of the website.
And don't forget to check out the podcast t-shirt at talkpython.fm/shirt.
Our theme music is Developers, Developers, Developers by Corey Smith, who goes by Smix.
You can hear the entire song on our website.
This is your host, Michael Kennedy.
As always, thank you so much for listening.
Smix, take us out of here.
Stay tuned.