DEV Community: Sean Francis N. Ballais

How and Why Do You Use GitHub Projects?

Sean Francis N. Ballais — Fri, 07 Jun 2019 03:41:28 +0000

I'm used to using Trello for project management, and I'm using it for a new project I'm working on. I encountered GitHub Projects just yesterday, and I'm wondering what its use case is or advantage over Trello (aside from it being under the same roof as your repos).

For me, I see no significant advantage of it over Trello. The only scenario I would see that involves using GitHub Projects is when you would use Trello for general project management, with developer tasks delegated to GitHub Projects. However, I find that problematic since non-developers would not immediately know the progress and problems encountered during development, and devs would not be able to immediately know the progress and issues in non-dev-related tasks. You could duplicate items from GitHub Projects to Trello, but that would mean that there would be duplication of items, and additional work would be needed, unless there would be an integration between the two.

I'd like to know your thoughts on GitHub Projects, and how and why you use it.

I need help refactoring the database module where all the creation, insertion, etc. code are in their own respective files.

Sean Francis N. Ballais — Mon, 25 Jun 2018 02:43:37 +0000

NOTE: I was given permission to post the codes here.

I am in my internship currently. We are maintaining a system that is quite used in the organization. It is written in Java. I am assigned to refactoring the code and I chose to work on the database module, thinking it was just an easy job to do.

When I saw the code, it is full of singletons and I feel that the module could be done in a better way. One of the classes in the module is InsertDatabase. It handles every data insertion. It looks like this:

public class InsertDatabase {
    private static InsertDatabase instance = null;

    private Properties prop = new Properties();
    private InputStream input = null;

    private InsertDatabase(){
        try{
            input = new FileInputStream("textfile/sql_queries.txt");
            prop.load(input);
        }catch(Exception e){
            System.err.println(e);
        }
    }

    public static InsertDatabase getInstance(){
        if(instance == null) {
            instance = new InsertDatabase();
        }
        return instance;
    }

    public void insertIntoCourseTable(String course_abbr, String course_name) {
        Connection conn = cpInstance.getConnection();
        try(PreparedStatement ps = conn.prepareStatement(prop.getProperty("insert_course_table"));) {
            ps.setString(1, course_abbr);
            ps.setString(2, course_name);
            ps.executeUpdate();

            Helper.getInstance().aprintln(this,Helper.LOG_VERBOSE,"");
            Helper.getInstance().aprintln(this,Helper.LOG_VERBOSE,"*** Information Added into Course Table***");
        } catch (SQLException e) {
            Helper.getInstance().aprintln(this,Helper.LOG_VERBOSE,"Data already exists");
        }finally {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    // more code...
}

This is also the same case with the other classes assigned to table creation, updating data, and selecting data.

The SQL queries are actually stored in a text file called sql_queries.txt and is loaded in the variable props. The text file is almost 200 lines long. Here's a sample line from the text file.

insert_diagnostic_table = insert into diagnostic_table (date_start, date_end, sem_num, freetime, time_penalty, balance_penalty) values (?, ?, ?, ?, ?, ?)
insert_pasa_balance_table = insert into pasa_balance_table (date_rendered, sender, amount, current_balance_sender, deducted_balance_sender, receiver, current_balance_receiver, added_balance_receiver) values (curdate(), ?, ?, ?, ?, ?, ?, ?)

The classes are then herded into a singleton class called Information, which the system uses to interact with the database. The class looks like this:

public class Information {
    private static Information instance = null;

    private InsertDatabase insert_db = InsertDatabase.getInstance();
    private SearchDatabase search_db = SearchDatabase.getInstance();
    private UpdateDatabase update_db = UpdateDatabase.getInstance();
    private DeleteDatabase delete_db = DeleteDatabase.getInstance();
    private TransDatabase trans_db = TransDatabase.getInstance();

    public static Information getInstance(){
        if(instance == null) {
            instance = new Information();
        }
        return instance;
    }

    /*
     * Here lies all of the methods that access DeleteDatabase
     */

    public void storeToDeleteReservation(String username) {
        delete_db.deleteReservation(username);
    }

    // more code...

    public void storeStudentToDelete(String username) {
        delete_db.deleteStudent(username);
    }

    /**
     * Deletes Staff
     * @param username
     */
    public void storeStaffToDelete(String username) {
        delete_db.deleteStaff(username);
    }

    /*
     * End of methods that access DeleteDatabase
     */

    /*
     * Here lies all the methods that access InsertDatabase
     */

    public void storeAccountInfo(String username, String password, String last_name, String first_name, String mid_name, String suffix_name){
        insert_db.insertIntoAccountTable(username, password, last_name, first_name, mid_name, suffix_name);
    }

    public void storeCourseInfo(String course_abbr, String course_name) {
        insert_db.insertIntoCourseTable(course_abbr, course_name);
    }

    // more code...
}

I have a weird feeling that there are problems with this. I can't pinpoint exactly what the problems are. Having them as singletons is a warning flag for me already. So, are there any problems with the approach?

What I was thinking to do was to create a DAO (data access object) for each table and have the rest of the system use the DAOs instead. If I proceed with DAOs, I'd modify Information first so that I would not touch the rest of the system and accidentally break anything. If I do break anything, at least I know where I screwed up. What do you think?

Thanks! :)

I Made a Dev-Related Comic Strip - When You Add a New Feature Without Enough Tests

Sean Francis N. Ballais — Sun, 03 Jun 2018 22:06:00 +0000

What software projects have you worked on that doesn’t have tests? How was the experience? Let me know in the comments below.

P.S. I also created two comic strips and wrote a few articles over at my website. Go check them out!

I am kind of baffled by this code in the `init.py` file in my Python project. How does this work internally?

Sean Francis N. Ballais — Sat, 14 Apr 2018 14:44:33 +0000

So, I have the following Python code residing in the __init__.py file of my Python project which I autogenerated using PyScaffold.

from pkg_resources import get_distribution, DistributionNotFound

try:
    # Change here if project is renamed and does not equal the package name
    dist_name = 'mlfq-sim'
    __version__ = get_distribution(dist_name).version
except DistributionNotFound:  # pragma: no cover
    # Can't unit test this for now since I do not know how to temporarily
    # remove a distribution during runtime. Help. Also, is this even
    # worth it?
    __version__ = 'unknown'

I get that it gets the version of my project. But how does it do it? Is there a benefit in using it compared to the one below?

__version__ = 'some version'

How can I improve this while loop code snippet?

Sean Francis N. Ballais — Sun, 08 Apr 2018 08:26:59 +0000

So, I have this code snippet.

while (!Character.isWhitespace(this.source.charAt(this.currentCharIndex))) {
    char c = this.source.charAt(this.currentCharIndex);
    // ...
}

What it does is just basically loops through a string until it hits a white space character.

However, I find the code a bit messy. How can I improve it?

I can try this code snippet instead.

char c = this.source.charAt(this.currentCharIndex);
while (!Character.isWhitespace(c)) {
    c = this.source.charAt(this.currentCharIndex);
}

It looks cleaner but this.source.charAt(this.currentCharIndex) seems redundant (the same as the previous snippet) so I need your opinion on how you would tackle this problem.

Thanks! :D

I'm considering to use vim or neovim as my primary text editor. Any tips?

Sean Francis N. Ballais — Tue, 03 Apr 2018 09:35:49 +0000

I've been using VS Code as my primary text editor. Before, I have been using JetBrains's IDEs, Atom, and Sublime Text. I moved from IDEs to VS Code because a text editor is lighter than any IDE. I initially came from Atom. However, upon discovering and giving VS Code a shot, I was immediately hooked.

I've noticed that I'm using the terminal a lot these days. I wondered if I could use a terminal-based text editor instead. I think it makes perfect sense since I'm also using the terminal a lot. The text editor I have decided upon using is Vim. I also found out about Neovim minutes before I wrote this #discuss item. I think I'll use that instead of just vim.

So, any tips, things I should know, and/or fair warnings in using vim/neovim? What are your experiences in using any of the two?

Thanks! :)

Implementing a Simple Message Bus in C++

Sean Francis N. Ballais — Tue, 03 Jan 2017 14:33:00 +0000

Note: Alternative URL to the original post here.

Starting late December of 2016, I have been working on creating a 2D game engine for fun (and profit). It is not done yet. Most of the systems have not yet been implemented. Integration between graphics and physics is nonexistent. Key core components are nothing but ideas of the mind. What I recently finished working on was the message bus. It is already functional but it still needs improvement.

A message bus acts like the communication gateway between two or more components in a program, may it be business-oriented applications, or games. Without it, components can tend to couple themselves, and create a messy looking architecture.

In this article, we will be implementing a game-oriented message bus that you can use in your own project. Many applications, game engines, and games are written in C++ so we will be using that language. I recommend using C++14 because it is the latest C++ standard but this will compile in C++11 too.

What’s a Message Bus?

Applications and games normally are composed of multiple components. Each component is responsible for a task or a feature of the application. Sometimes, a component needs to ‘talk’ to another component. For example, your input system would need to “tell” your entity system that the player needs to be moved forward because the W key has been pressed. In code, you might implement it in this manner.

// Somewhere in the depths of your Input system.
if (Input.isPressed(Keys.W)) {
    Log.add("Siopao! Siopao! Siopao! Do not do it this way! Siopao! Siopao! Siopao!");
    player.move(10, 10);
    ...
}

Now, your input system is now informing the player to move forward. Game runs perfectly but there is a problem. Doing so couples your code. Coupled code is hard to maintain and is messy. Adding and removing certain parts would be more difficult as one change could entail changes in the other components. Creating a diagram on the overall system could result in each component connected to each other component. It looks messy.

To solve this issue, we would need to decouple the components from each other. A system that will allow communication between these components is what we need. This system is what we call a message bus.

A message bus is basically a modified large-scale Observer pattern. In the Observer pattern, there would be observers to receive notifications and subjects to send those notifications.

In a message bus, you have components sending and receiving messages to it. The message bus’s job is to route these messages to every component connected to it. Messages that each component send are basically events that happened. For example, a component may send a W_PRESSED message and the message bus will send that message to other components. The receipient is responsible with what it will do with the message.

One cool thing about message buses is that the sender does not even need to know if the message was received by another component or not. Heck! The sender should only be aware of the existence of itself and the message bus. It should not know the existence of the other components. The sent message can be silently ignored by the receivers (if there are any).

Implementing a Message Bus

Time to for the part you have been waiting for - implementing the message bus. The code here is adapted from the MessageBus component I have in my engine. We would start with implementing the Message class. We can implement it like this:

class Message
{
public:
    Message(const std::string event)
    {
        messageEvent = event;
    }

    std::string getEvent()
    {
        return messageEvent;
    }
private:
    std::string messageEvent;
};

The Message constructor accepts the string parameter event that contains the event that happened. The value of messageEvent can be something like W_PRESSED or PLAYER_FELL. Note that this implementation may differ from yours depending on your needs.

Next, we will implement the message bus itself where all components are connected to. This is how we can implement the message bus.

#include <functional>
#include <queue>
#include <vector>

class MessageBus
{
public:
    MessageBus() {};
    ~MessageBus() {};

    void addReceiver(std::function<void (Message)> messageReceiver)
    {
        receivers.push_back(messageReceiver);
    }

    void sendMessage(Message message)
    {
        messages.push(message);
    }

    void notify()
    {
        while(!messages.empty()) {
            for (auto iter = receivers.begin(); iter != receivers.end(); iter++) {
                (*iter)(messages.front());
            }

            messages.pop();
        }
    }

private:
    std::vector<std::function<void (Message)>> receivers;
    std::queue<Message> messages;
};

Well, that’s aplenty! Let’s explain what each function does.

addReceiver() This function adds a new receiver to the list of receivers notify() will loop through. A receiver is basically another component connected to the message bus. All receivers are stored in the receivers vector. This function should be called during the initialization of your program. We are accepting std::function objects so that we will be able to accept receivers that do not inherit from some sort of an Observer class. Also, the function name we pass can be different as long as the function has the same signature.
sendMessage() Adds a new message that the message bus will send to each component. All messages are added in a queue (messages in our case). We are using a queue so that we are guaranteed that messages are sent using FIFO (first in, first out). You do not want to be killed by an enemy first even though you killed him first, don’t you? This function is invoked by the component itself that has a reference to the message bus.
notify() This function sends all messages to each component. The first message in the queue is the first to be sent to each component and then popped off the message queue and so on. This function should be called during the game loop.

Next, we would need a base class where all components that uses the message bus will be based on. We will call this base class, BusNode.

#include <iostream>
#include <functional>

class BusNode
{
public:
    BusNode(MessageBus *messageBus)
    {
        this->messageBus = messageBus;
        this->messageBus->addReceiver(this->getNotifyFunc());
    }

    virtual void update() {};
protected:
    MessageBus *messageBus;

    std::function<void (Message)> getNotifyFunc()
    {
        auto messageListener = [=](Message message) -> void {
            this->onNotify(message);
        };
        return messageListener;
    }

    void send(Message message)
    {
        messageBus->sendMessage(message);
    }

    virtual void onNotify(Message message)
    {
        // Do something here. Your choice. You could do something like this.
        // std::cout << "Siopao! Siopao! Siopao! (Someone forgot to implement onNotify().)" << std::endl;
    }
};

Upon construction of a BusNode object, it will add its receiver function, onNotify, to the message bus so that it can begin receiving messages automatically. We have to use getNotifyFunc() to pass a std::function object containing a lambda function that calls our object’s onNotify(). The update() function is where we would perform update routines in our component.

We have now implemented a rudimentary message bus. You can now use this in your project and remix it according to your needs. But to finish this section on a high note, let’s create a simple example using those three classes we have built. Don’t forget to compile this under C++11 or C++14.

#include <iostream>
#include <functional>
#include <queue>
#include <vector>

class Message
{
public:
    Message(const std::string event)
    {
        messageEvent = event;
    }

    std::string getEvent()
    {
        return messageEvent;
    }
private:
    std::string messageEvent;
};

class MessageBus
{
public:
    MessageBus() {};
    ~MessageBus() {};

    void addReceiver(std::function<void (Message)> messageReceiver)
    {
        receivers.push_back(messageReceiver);
    }

    void sendMessage(Message message)
    {
        messages.push(message);
    }

    void notify()
    {
        while(!messages.empty()) {
            for (auto iter = receivers.begin(); iter != receivers.end(); iter++) {
                (*iter)(messages.front());
            }

            messages.pop();
        }
    }

private:
    std::vector<std::function<void (Message)>> receivers;
    std::queue<Message> messages;
};

class BusNode
{
public:
    BusNode(MessageBus *messageBus)
    {
        this->messageBus = messageBus;
        this->messageBus->addReceiver(this->getNotifyFunc());
    }

    virtual void update() {}
protected:
    MessageBus *messageBus;

    std::function<void (Message)> getNotifyFunc()
    {
        auto messageListener = [=](Message message) -> void {
            this->onNotify(message);
        };
        return messageListener;
    }

    void send(Message message)
    {
        messageBus->sendMessage(message);
    }

    virtual void onNotify(Message message)
    {
        // Do something here. Your choice. But you could do this.
        // std::cout << "Siopao! Siopao! Siopao! (Someone forgot to implement onNotify().)" << std::endl;
    }
};

// This class will receive a message from ComponentB.
class ComponentA : public BusNode
{
public:
    ComponentA(MessageBus* messageBus) : BusNode(messageBus) {}

private:
    void onNotify(Message message)
    {
        std::cout << "I received: " << message.getEvent() << std::endl;
    }
};

// This class will send a message to ComponentA.
class ComponentB : public BusNode
{
public:
    ComponentB(MessageBus* messageBus) : BusNode(messageBus) {}

    void update()
    {
        Message greeting("Hi!");
        send(greeting);
    }

private:
    void onNotify(Message message)
    {
        std::cout << "I received: " << message.getEvent() << std::endl;
    }
};

int main()
{
    MessageBus messageBus;
    ComponentA compA(&messageBus);
    ComponentB compB(&messageBus);

    // This is supposed to act like a game loop.
    for (int ctr = 0; ctr < 50; ctr++) {
        compA.update();
        compB.update();
        messageBus.notify();
    }

    return 0;
}

The output would look like this.

Conclusion

We have implemented a message bus that allows intercomponent communication and decoupling of our system. Our message bus consists of three classes: BusNode, the base class for our components depending on the message bus; Message, the class the messages we send depends on; and MessageBus, the message bus implementation itself.

What we created is just a basic message bus. The message bus is usable but it surely needs improvements. One way you can build upon this is by adding a mechanism where receivers can subscribe to specific messages. To allow comparison between messages, we can use message IDs. The IDs should be hashed (try FNV-1A) to allow fast comparisons.

For further reference, you may want to check out OpTank’s article on message buses. Michael Kissner’s article about messaging in a game engine in Gamasutra can be helpful as well.

Do not take what we have created as is. I intended it as a foundation from which you can build your own message bus. I recommend deviating from the code here. Do not forget to plan before you code. Adapt what you have learned here and apply it in your own message bus or any project you have at hand.

Are you currently working on a project? How did you process communication between your project’s components? Do you have something to share? Let us know in the comments below.