DEV Community: R0land013

Dev Links launch

R0land013 — Fri, 11 Aug 2023 20:14:10 +0000

Hi there👋. I present you 🚀Dev Links. An open source browser extension that allows you to find useful tools for developers and designers, helping you to increase your productivity and keep you focused.

With this extension you will have a list of tools ready for you to browse. All tools are seperated by categories, so you can find fast what you wish.

Dev Links allows you to select your favorite links for quick access.

You can contribute with more links to the project in its repository. The repo of Dev Links is this.

Downloads

You can download DevLinks for Chrome, Opera and Brave here.
For Firefox you can get the extension here.
Dev Links will be publicly available for Edge soon.

Support Dev Links in Product Hunt so it can reach more persons.

Construct MVP PyQt5 application easily

R0land013 — Sun, 12 Jun 2022 01:14:03 +0000

Hello everybody I created a python package to easily construct a MVP PyQt5 application. I will leave here the content of the project's README.md.
You can review the source code here.
And you can find the pacakge in pypi.

Description

easy_mvp is a package that makes it easy to build desktop applications
using MVP pattern, Python and PyQt5. This is achieved by using
a set of classes and practices similar to those used in the Android framework.

The basic idea behind this package is to open a presenter from
another presenter and that the new presenter fills the window for
complete. This is similar to Android applications, which
when opening a new Activity, they replace the old one with the new one.
If the Back button is pressed, then the new Activity is removed
and the old one reappears on the screen. This gives the impression
that there is a stack of Activity.

In addition, easy_mvp offers the possibility of doing the above in more than
a window, since desktop applications are very different to Android apps.

Installation

To install this package you need to have Python installed in your system.
Then you can run this command to install this package:

pip install easy_mvp

Explaining the mechanism

The following explanations are reflected in demo.py program.

The application model created by easy_mvp is like this:

The ApplicationManager class is the entry point of the program. This
class is the one that knows the windows, creates them and destroys them. Each
window holds a stack of presenters. In this way it is implemented
the same behavior that Android applications have. Class
Intent is used to transition from one presenter to another,
regardless of whether the new presenter is started in a new window.

The behavior of the windows is represented as follows:

As you can see the window has a stack of presenters, the
which are attached to their views, therefore all the
presenters must possess a view. Again we can see that the class
Intent is the one that allows to add a new pair of presenter-view
to the window stack. For this mechanism to work, the presenter
classes must inherit from the AbstractPresenter class.

AbstractPresenter has several methods to open new presenters,
close the current presenter and to handle certain flows within the
application, such as when a presenter is going to be initialized, hidden,
or closed.

The flow of events in a class that inherits from AbstractPresenter is like this:

The _on_initialize method is the first method called in the AbstractPresenter class.
Here the instance variables of the presenter must be initialized. Also you must
create the instance of the view that corresponds to the presenter. Once created,
the view instance must be set with the _set_view(view) method, from
this way the view is made accessible to the rest of the classes in easy_mvp environment.
The view can be obtained with the get_view method of AbstractPresenter, if it was set
by _set_view(view) first.

The on_view_shown method is called just after the presenter view
is displayed in the graphical interface. In this method the data should be loaded,
and the tables and forms filled.

If on the presenter whose view is visible, _open_other_presenter is called
then another presenter will be created, and this presenter will go to the top of the
stack of presenters, and its view will be the only one visible in the graphical interface.
The view of presenter that called _open_other_presenter will no longer be visible.
Before this last occurs, the calling presenter will receive control of the program
with the method on_view_covered.

If now the top presenter calls _close_this_presenter, then the
presenter view just below it will be visible again, and the
presenter will receive control of the main thread via on_view_discovered.
In this method the view should be updated due to some change in the model.

When the presenter at the top of the stack calls _close_this_presenter
receives the control with the on_closing_presenter method. In this method
resources should be released and observers removed. After the call to
on_closing_presenter the presenter and the view of the presenter will be
removed and it will happen what it has been explained previously.
It should be noted that if the presenter who closes is the
only one that exists in the entire application, that is, there is only one
window and it owns only a presenter then the application will close with
the status code 0. To close the program with different code, use the exit_app
method of AbstractPresenter.

Receiving data from presenters

A presenter can receive data from another presenter that it has created,
if the second one is closed using the _close_this_presenter_with_result(result_data: dict)
method. In this way, the presenter that is below in the stack receives control of the
program via on_view_discovered_with_result(action: str, data: dict) instead of
on_view_discovered. The action parameter is the action that was passed to the Intent when
it was ordered to open the new presenter. And result_data is a Python dictionary that the
presenter who was on top can pass through
_close_this_presenter_with_result(result_data: dict).

Managing global data

Data can be created to be accessible throughout the entire application. This is
accomplished with the set_global_data(key: str, data) and get_global_data(key: str)
methods of AbstractPresenter. You can also check if a global data exists with the method
has_global_data(key: str), which returns True if it exists and False otherwise.

Knowing Intent in depth

As explained Intent is what makes it possible to open new presenters. You can specify
that the new presenter must be opened on a new window using
use_new_window(use_new_window: bool = False). You can also specify that
if a new window is to be opened, then make it modal or not with the method
use_modal(self, modal: bool = False).

An intent can be specified with an action with set_action(action: str), like so
the new presenter may behave differently depending on the action received.

Intent also allows data to be passed to a new presenter via set_data(data: dict).
To see examples of how Intent is used, check out the demo.py program.

Guess Number Game with Android

R0land013 — Sun, 19 Dec 2021 03:51:05 +0000

In this post I show you a simple game for practicing android development. It uses MVP design pattern.
You can find the code of this app here.

The game is called 'Guess Number'. The target is to guess a number between 1 and 100, using 10 intents or less.

This is a simple challenge for android beginners. It uses some basic components of android apps, as Activities, Intents and Fragments. Also the app uses some simple styles and other sources.

Multiple Scenes JavaFX MVP

R0land013 — Mon, 25 Oct 2021 18:46:42 +0000

I made a demo about showing a way to create a multiple scene JavaFX application using MVP.

If you are not familiarized with MVP you should first understand it.
You can read about it here .

The source code is here.

About

I was finding a way to create a JavaFX application using only one window or stage, and
multiple scenes. The way I wanted to achieve it, was creating a mechanism to manage
the presenters using a stack. Doing that I could navigate between the presenters
and the scenes in a common manner, openig new pairs of presenter and view,
and being able to return to previous opened presenters.

And I wanted to got it without making a great effort in every presenter source code.

The Solution

Principal Classes and Interfaces

PresenterManager:

This is the most important class. It manage the transitions between presenters.
The presenters notify this class to add presenters or close them.

AbstarctPresenter:

All presenters must extends this class, because it defines the interfaces to
comunicate with the PresenterManager class. This class use notifyManagerToAddNewPresenter()
and notifyManagerToDeletePresenter() methods to achieve it. These method are protected.

PresenterView:

All views must implement this interface. It has the method getViewScene() to retrieve the
javafx.scene.Scene object from the view object. This method is used by
the PresenterManager to set the visible scene.

Explaining the mechanism

First, all presenters classes must extends the AbstarctPresenter class and implement
all abstract methods:

getDerivedPresenter(): is used by PresenterManager to retrieve a new presenter
to be opened. Inside this method you can use a switch statement or something similar to
return an instance of the wished presenter, because one presenter could open
different presenters. For example you could have an application which shows a window
with two button, the first to open a CRUD scene of products and the other a CRUD
scene of clients.

getPresenterView(): is used by PresenterManager to retrieve the PresenterView
of the presenter to be opened. And then get the javafx.scene.Scene from it.

Second, you have to implement methods which calls notifyManagerToAddNewPresenter()
and notifyManagerToDeletePresenter() to add new presenter and delete current presenter
respectively. See the source code of this project.

Third, in the views of your presenters you have to set the listeners in buttons or widgets
you want to fire the events of opening or closing presenters, and bind it with the methods created
in the previous step. And you have to implement the getViewScene() method to return the javafx.scene.Scene
from this view object. See the source code of this project.

Fourth, in the start(Stage) method of your Main class create an instance of PresenterManager
and set the initial presenter with setInitialPresenter(AbstarctPresenter). Then you can call the
show() method of AbstarctPresenter to show the stage or window of your application.

You can always check the source code of this project, if you did not understand this description.

Images of the demo

First scene

Second Scene

Third Scene

Little TV Series Survey using pure HTML, CSS and Javascript for practicing those technologies.

R0land013 — Thu, 26 Aug 2021 03:52:53 +0000

Hello everybody! I feel so happy because I have just
created my second web page using pure HTML, CSS and Javascript,
and I loved the result.

This web page, was created to practice the mentioned technologies.
It let you choose a series from 'The Big Bang Theory', 'Mr. Robot'
and 'Game of Thrones'(Some of my favorite series). When you choose
the series, the web page will show you some data about it, and it
will let you choose your favorite character from that series. Then
you have to leave a comment about why did you like about that series.

When you click 'submit', a thankful message will appear.

It also validate that you are selecting a series and leaving a comment.

The repository of this little project is:
https://github.com/R0land013/TV-Series-Survey

Leave a comment showing what do you think about this practice.

My first web page

R0land013 — Tue, 24 Aug 2021 04:18:00 +0000

¡Hello World! This is my first web page. It is my first
step toward becoming a developer.

This web page is about showing my favorite programming languages(Java, Python and C++) and its histories.
This page was created using HTML and CSS.

Where to put regular expression checks?

R0land013 — Sun, 01 Aug 2021 19:50:26 +0000

Hello. I would like to know where should I check if a specific attribute matches with some regular expression. Should I do it in the class or in the database. For example imagine I have an User class, which has an email attribute, and I need to check if a given value for that property is correctly written. Also imagine I need to store the users in a database. Where should I check for the correctly written email, in the code inside the User class, in the database or both? Thank you.

Why I like statically checked languages?

R0land013 — Sat, 31 Jul 2021 23:16:00 +0000

Hello, first of all, please, apologize my English; I am not an English speaker. I’m a beginner programmer, and the first programming language that I used was Python, a dynamically checked language. I used it to create my final project of 1st career year. It is incredible how easy python is. I was implementing that project very fast (without testing, creating messy code, messy architecture, due it was the first time I was creating an app) and I was very happy by how quick I was going ahead. But when I start to mix some classes and objects, and I started to test how was working my app, a bunch of errors were started to fall over me. I spend a long time to find and fix all bugs, some of them very hard to track for me. Many bugs which I found were given by the fact I was writing incorrectly the method names, also I was passing wrong argument types to methods, it seemed I have a bad memory😅.

Luckily, I could terminate implementing all the application correctly, functionally speaking, but it was a difficult and painful process. I was very excited, because I had built my first app and I leaved a huge weight.

The next year I had to create a similar project, but using Java language. When I started to learn Java, I suffered a terrible headache given by all the features that this language has. I was coming from the beautiful, simple and lazy Python’s world. My mind blew when I saw ‘final’, ‘static’ ,‘public’, ‘private’, ‘protected’, ‘void’, ‘char’, ‘boolean’, ‘byte’, ‘short’, ‘int’, ‘long’, ‘double’, ‘float’, ‘interface’, ‘abstract’ words and its syntax. It was uncomfortable for me to learn Java given the first programming language I learned was Python. But when I knew its fundamental features I felt better, and now I like it more than Python.

When I started to create the new app it was easier. I did not suffer errors similar to those I found in my Python program. The static checked of Java was saving me from a great quantity of subtle errors, and the IDE became my first friend due its auto completion and the errors markers. These things were reduced in my Python IDE (IntelliJ IDEA Community Edition with Python plugin) due its dynamically checked.

After living this experience of constructing similar apps with different languages, with different checked system I formed the next opinion:

-Dynamically checked languages are easier to learn than static checked languages. Since you do not need many reserved words, features and syntax and languages constrains in a language like Python, the process of learning becomes short, compared with statically checked languages like Java and C++. Also the code with a language like Python and JavaScript (dynamically checked languages) is short, and easy to read.

-The code written with statically checked language is easier to understand than dynamically checked language. Because you are obligated to declare the returned type, and the parameters type when using a statically checked language, I could say that this kind of language is auto documented. This is good, but it is not enough to leave writing specifications (preconditions and post conditions). Now, think you are using Python and you need to use a function written by a team-mate, but he is lazy and he did not document it. How do you know what this function needs and returns? You have to read the function code, and spend some time in it. This happens because dynamically checked language does not obligate coders to give this information.

-Statically checked language save you from a great quantity of subtle errors. If you use a data type as an argument in a method call being different from the expected, then you will be notified by the IDE with a red mark, and the compiler will notified you with an error in compile time. With dynamically checked languages you can have these errors and the interpreter will never notified you, and you will have this hidden bug until the interpreter raise an exception as consequence of a method(or access to a property) call in an data type object wich does not have that method.

All this makes me love statically checked languages. But dynamically checked languages have beauty too. Since these are short and simple you can code faster. It is very useful in competitive programming and in game programming contests. For example Python is very used for competitive programming and the majority of online judges allow it, and it is better to quickly write algorithms. Also there is a Python framework called Pygame which is very used in game programming contests.

I hope you had learned something new or had read something interesting. If you see knowledge error in this post, please, tell me what it is. Give your opinion in this topic.

What is your favorite programming language, and is it statically or dynamically checked?
-The mine is Java😁.