DEV Community: TobiasHT

Starting my Journey to contributing to Python

TobiasHT — Tue, 28 Dec 2021 11:22:31 +0000

Hey Devs.
So I've been using Python for quite a long time now. I have used it in a variety of projects, some open source while other proprietary, all ranging from graphics, to web, to data science and many other sectors in IT.
I'm mainly a freelancer at this point, so that's why I get to work on a wide range of projects.

However, this month I decided to take a big step and try to contribute to CPython. CPython is the most common implementation of python for those that don't know it, other implementations include PyPy, IronPyton and Jython, you can look them up if you wanna know more about them. We're here to talk about CPython mainly and how to get started.

Rest assured, other than using the language itself, I generally have no idea how CPython is implemented, and I'm also not 100% good at Python itself, I'd give myself 85%. So I'm gonna start documenting my journey through a series of blog posts that I'm gonna be making here. I hope by the end of this journey, I'd have achieved my goal of contributing to CPython, and I hope we move together in this awesome Journey.

So now where I'm starting from you wonder? Well, I started where everyone who wishes to contribute to python starts from, the python devguide https://devguide.python.org/ and I read through it quite carefully.
Second, I needed to learn how python works on the inside, and for that I purchased my copy of CPython Internals by Anthony Shaw, this is quite a great book I might say.
Thirdly, I had to get myself a copy of the CPython source code from GitHub, which I downloaded as a zip from here https://github.com/python/cpython .I downloaded the recent Python 3.10 source. I did not want to clone the python 3.11 project because it is continuously changing and I wouldn't be able to keep up with the changes.
Fourthly, I needed to find a community of developers where I can ask questions when I face a challenge. Thankfully, I landed on the Python discussions site https://discuss.python.org/ . This is the place where core developers and New users sit back and talk python all day (that's if they got time to talk).

Well, I think my ingredients are set. Since the year is coming to a close, I guess there's not much I can do this year. However, before this year ends, I realized that It's important to learn how to embed and extend python and also learning the Python-C API. This is very useful to learn as it gives you a glimpse into the internals of CPython and also has a wide range of applications in cases where you wanna add extra functionality to your python interpreter.

Alright, that's it for me for now. Next up, learning the Python-C API and how to extend python with some C code. If you wanna follow along, you can find the Python-C API documented in the python docs. Happy learning, and let's start off with the journey.

Introduction to the Kivy development cycle, KIVY 2.0

TobiasHT — Tue, 22 Jun 2021 22:11:36 +0000

Hello Devs, This is the second article I'm writing about how to develop mobile apps with Python and the kivy framework.
Last time we talked a little about kivy and we were able to compare it with other mobile frameworks. We also compared it to flutter and saw the valuable advantages it has over it.
Today, we're starting our first phase of learning the actual Kivy framework.

Kivy in a nutshell

Let's talk about Kivy's structure for a second.
Kivy is built on top of SDL2, a powerful C graphics library. The link between the SDL2 C code and the Python code built on top of it is built using Cython.
The kivy project folder contains various python modules. You will not be able to interact with all these modules directly, because some of them are abstract and are used to implement concrete modules.
That being said, the main modules in the kivy package that you will interact with the most are:

app
uix
graphics
lang
core
properties

Proceeding, those aren't the only modules you will need to build an optimized app. However, they are the basic parts you'll not miss out while building any app in Kivy. But what exactly is contained in these modules, let's find out.

app

The app module contains the App class.
The App class is the main entry point for a user into your application. It runs the entire application loop that the user will interact with. Import the App class as shown below

from kivy.app import App

if you're using python interactively, you'll see something like this on Windows

Kivy will start up some dependencies that it relies on such as SDL2, Gstreamer and many others. Once the loading process is done, now you can start building some UI elements.

uix

The uix module is one of the biggest kivy modules. It contains the implementations of all of Kivy's UI elements suchs as buttons,labels,text inputs and many others.
The uix module contains submodules that are written in small letters. The submodules contain classes with the same name as the submodule, but with the first letters capitalized.
for example

from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.boxlayout import BoxLayout

The widgets in the uix module are divided into the Display widgets and the layout widgets.
The display widgets are the ones that physically appear on the user's screen while the layout widgets provide means to organize the display widgets in a certain pattern.
For example, the boxlayout organizes widgets vertically or horizontally, the gridlayout organizes widgets in rows and columns and other layouts organize widgets in various ways.

use what we have so far

Lets see how we can display a simple button in kivy.
here we go

from kivy.app import App
from kivy.uix.button import Button

class ButtonApp(App):
    def build(self):
        return Button(text = "my-first-button")

if __name__ == "__main__":
    ButtonApp().run()

Alright, if you very new to a framework, seeing code like this might throw you off a little. This is actually simple code to read, but the questions on how it works are the most aching. Let me try to answer some here.
First, we imported our App class like we discussed above. However, this class is an abstract class, that is, it has "empty" methods that need to be implemented by the subclass or child class.
One of those abstract methods is the build method. This method returns the root widget of the Kivy application that shall be ran.
In our build method, we returned a button widget as our root widget with "my-first-button" as our display text.
Finally, we used the standard default conditional statement to run the script and we called the run method of our ButtonApp. the run method is actually implemented in the App abstracted class which we subclassed.
Once we run this script, we get a big gray button that fills up the entire app window. The button turns blue when pressed and changes back to gray when released.

conclusion

That's it for today. I've just merely given you a glimpse about kivy. It surely gets more complicated than that. However once you master this framework, the apps you'll build will be incredible.
We shall keep discussing the rest of the modules as time goes on. For today however, this is where it ends

KIVY INDEPTH SERIES, KIVY 2.0

TobiasHT — Sat, 12 Jun 2021 12:05:23 +0000

Hello there, My Name is Higenyi Tobias Thomas, but you can just refer to me as Tobias HT.
I am a programmer and have been coding in mainly Python and C for the past 6 years.
I deeply fell in love with python, it had everything I ever needed. However, there was mainly one problem. Other than the developer community, many software users detest the use of commandline interfaces, and others are even afraid of them.
Also software users love beautiful and interactive graphical user interfaces that Python's default GUI suite(Tkinter) and others simply cannot offer.

That's why I'm presenting to you, KIVY 2.0.0.
Kivy is a beautiful, cross platform library that adds a professional look to your GUI applications. Version 2.0 was released in December 2020, and it's the latest release that comes with major bugfixes, faster speed improvements and much more.
It has a rich support for multimedia such as Images and videos of various formats. It provides a consistent look and feel of your app over all major mobile and desktop platforms.
You can checkout more about kivy here.

My Job here is to make you a pro at the kivy framework. We are going to learn how to develop beautiful apps and also how to compile them for both desktop and mobile. I shall be using the windows platform for desktop and Android for mobile. The examples shall be sufficient to compile to both iOS and MacOS. I do assume though, that you are sufficiently good at the python programming language, that's what we're gonna be using. Without further ado, let's dive in.

comparison between Kivy and flutter

Before we dive deeper into kivy, I'm sure you're wondering why you would rather choose kivy instead of the hundreds of other frameworks out there that can do the same job, most notably the flutter framework. Well, here is a couple of reasons why.

Language in use

Kivy uses Python language for development of apps, Python has been battle tested, very fast, and easy to learn. It's used in the highly computational field of Artificial intelligence and Machine Learning and other fields of Science. Flutter on the other hand uses Dart language, a relatively new language that is still under going various tests and not really recommended for large scale production because of it's high volatility.

Rendering Engine

Kivy uses the SDL2 Engine, a very powerful GPU based rendering engine to display the user interface. The advantage of using sdl2 is that all the graphics that are displayed on screen are created by the fast GPU. On the other hand, Flutter uses the Skia Engine, a very powerful CPU based rendering engine. The skia engine is great when it gets to render simple user interfaces, however due to it's CPU constraint, it doesn't do well when it gets to rendering intensive apps like 3D games, simulations and more.

FrameRates

Kivy has a minimum framerate of around 75 frames per second, which immerses the user in a fluid app experience with almost Zero latency. This frame rate can go up 125 frames per second. while flutter provides a frame rate of 60 frames per second and barely any chance of increasing the rate speed. This is the major cause of the latency in the user experience of flutter apps.

App size

Kivy framework produces very light weight, highly compact and extremely fast App bundles for all the major platforms. Flutter on the other hand produces large app bundles which are almost twice and in worse cases, three times bigger than the ones produced by Kivy.

Native platform interaction

All frameworks have to be able to provide a way an app can interact with the system features of the underlying native platform. Kivy provides a simple way to call native android and iOS system calls with in the app through a Java Bridge and Objective C bridge which is extremely fast. Flutter on the other hand provides a message passing solution where the flutter app calls to native code and acquires results through a simple message. This is relatively slow compared to kivy.

Conclusion

I could write about the differences between kivy and other platforms as well, but that will be much talk and yet we need to get down into business. Instead of telling you why Kivy is better, I am going to show you why.
This has just been the introduction to this series and you should expect much more.
The next 5 articles will include:
1) introduction to the kivy app development cycle
2) introduction to kivy widgets
3) introduction to kivy events
4) introduction to kivy graphics
5) compiling kivy apps for mobile and desktop

Python is a Superpower. Industries that are using Python today

TobiasHT — Thu, 05 Nov 2020 05:36:09 +0000

Python language has proved to be the Superpower of computing these days. Even when a lot of critics come out to speak against it, it still persists and infact grows even stronger, why is that?
First of all, python has the easiest syntax in the world, it's literally just plain text. So it's easy to grasp.
Secondly, it doesn't have a lot of tricks behind it, you can literally master the whole entire python language in a matter of days.
Thirdly, Python is not really that fast, but the power it has to be highly extensible and embeddable adds extra boost to it's speed using tools like cython.

For that reason, Python has been used in very many industries, here's a afew.
As a graphics major, python has become the de facto language for graphics scripting with industry standard software such as Houdini, Autodesk Maya, 3DsMax, Blender and so many others use Python for scripting.
Google's search is actually built with python.
Almost all Artificial intelligence tools today are built with Python including Tensorflow and Pytorch which are the leading standards.
Reports have also noted a large increase in malicious software written in Python, this means that system security and encryption is being developed and tested in Python these days.
Python is coming to mobile, with open source projects like Kivy and BeeWare pushing the boundaries to Port Python to all the major mobile operating systems. You can actually build mobile apps with Kivy or BeeWare's Toga.
Game scripting is now days done with Python, the most famous is EveOnline built with stackless python.
I could go on and on but I beg to end here, you can include more industries that use Python in the comments below

The return of goto

TobiasHT — Fri, 31 Jul 2020 09:36:17 +0000

The goto statement is one of the most obscure statements in C and C++.
This could be due to the fact that not a lot of tutorials and books teach about it. But mainly it's due to the mishandling of the goto statement by our ancestor programmers.
This all began when C language had just gained traction. Many assembly programmers hopped on to the C ride and began building complicated programs with the goto statement in C which was more familiar to the goto statement in assembly.

goto statement works in such a way that it tells your program to execute the section of code that the goto statement points to. This statement may be with in any scope of the code being executed.
The goto statement represents how the CPU actually performs some of it's execution, hence it's more close to the machine.

However, due to the mishandling of the goto statement by our ancestor assembly programmers, goto was generally shunned by the developer community and it's currently considered bad coding practice to use it.

But it doesn't have to be that way. In fact all the C and C++ compilers in existence support it anyway, so why not use it. We just have to provide Standard means on how to use them.

First, among the confusing things done by the ancestor programmers was to declare labels within other functions and have goto statements point to them. This was generally confusing because the function declares it's own local scope, so having another function point to that functions scope was confusing. Mostly because it was hard to find where the goto statement was actually pointing to.
So generally it would be better to make all labels as globally scoped.

Secondly, the labels themselves should have a standard notation. Pointers in C and C++ are written with _ptr as a suffix and it's a generally accepted notation. Labels can also be written with a _lab suffix to denote that it's a label, for example endProcess_lab could be a label for a section of code that closes a process when an error is encountered.

I can give many reasons as to why goto statement should return, but it would make this article longer and more tedious to read than it already is.
It's just a polite suggestion to the developer community that I hope shall be put into consideration.