DEV Community: Emalp

At this time of peak world crisis on climate change, do you think there is something we could do as developers to help?

Emalp — Sat, 18 Jan 2020 21:36:35 +0000

Writing a simple SMS sending reminder app for absolute absent minded people like me.

Emalp — Fri, 13 Dec 2019 01:23:43 +0000

I am very very very forgetful and am too lazy to do anything about it. I wanted the simplest form of reminder where I would not need to download any complex apps and the notification sent by the reminder would repeat itself after a certain specified days.

Finally I gathered the guts in my uni holidays to write something that is absolutely in it's simplest form and would hit in the most precious human activation zone; the SMS text. So I'll try and write a simple program that sends me a SMS every certain days with a special message.

For this I'll be using the Telstra SMS API. It gives us 1000 free SMS which is enough for me as I'll be sending maximum of just 2 SMS per week, thats only about 104 SMS per year. I'll also be utilising the python Schedule module to help me manage my schedules. So let's begin!

First of all lets import all required stuff:

from __future__ import print_function
import time
import Telstra_Messaging
from Telstra_Messaging.rest import ApiException
from datetime import datetime

Now lets setup the Telstra SMS API:


class SMSender():
    client_id = 'your_client_id' # str | 
    client_secret = 'your_client_secret' # str | 
    grant_type = 'client_credentials' # str |  (default to 'client_credentials')

    def __init__(self):
        self.configuration = Telstra_Messaging.Configuration()

    def authenticate_client(self):
        api_instance = Telstra_Messaging.AuthenticationApi(Telstra_Messaging.ApiClient(self.configuration))

        try:
            # Generate OAuth2 token
            self.api_response = api_instance.auth_token(self.client_id, self.client_secret, self.grant_type)

        except ApiException as e:
            print("Exception when calling AuthenticationApi->auth_token: %s\n" % e)

    def provision_client(self):
        self.configuration.access_token = self.api_response.access_token
        api_instance = Telstra_Messaging.ProvisioningApi(Telstra_Messaging.ApiClient(self.configuration))
        provision_number_request = Telstra_Messaging.ProvisionNumberRequest() 

        try:
            # Create Subscription
            api_response = api_instance.create_subscription(provision_number_request)
            api_response = api_instance.get_subscription()

        except ApiException as e:
            print("Exception when calling ProvisioningApi->create_subscription: %s\n" % e)

    def send_sms(self, msg_to, msg_body):
        api_instance = Telstra_Messaging.MessagingApi(Telstra_Messaging.ApiClient(self.configuration))
        send_sms_request = Telstra_Messaging.SendSMSRequest(to=msg_to, body=msg_body)

        try:
            # Send SMS
            api_response = api_instance.send_sms(send_sms_request)
            return True

        except ApiException as e:
            print("Exception when calling MessagingApi->send_sms: %s\n" % e)

As you can see, each function does a specific work.

authenticate_client

Authenticates with our client id and secret with the Telstra API. After that

provision_client

provision's our client with a new phone number. In the end

send_sms

is a simple method to send SMS to whatever phone number with specific message.

Now for the fun part, let's start to code our Scheduling portion of the program.

We will have 3 functions for this part.
The first one is add_repeat_sequence:

def add_repeat_sequence(self, date_from=datetime.today(),\
         repeat_after_days=1, at_time="09:30", msg="This is your alarm!!", to="0444444444"):


        right_now = int(datetime.today().timestamp())
        date_from = int(date_from.timestamp())

        if date_from < today:
            raise ValueError("date_from cannot be before right_now")
        else:
            time_diff = date_from - right_now

            t = Timer(time_diff, self.set_alarm, [repeat_after_days, at_time, msg, to])
            t.start()

This function is to basically set an alarm at an specified date, given by "date_from". After our timer completes it runs the "set_alarm" function with the parameters given in the list.

We will now write the "set_alarm" function which is passed in the Timer's parameter. This function will be called when our timer setting date has approached.

    def set_alarm(self, day_diff, time_alarm, msg, to):

        self.send_alarm(msg, to)

        if day_diff <= 1:
            schedule.every().day.at(time_alarm).do(self.send_alarm, msg, to)
        else:
            schedule.every(day_diff).days.at(time_alarm).do(self.send_alarm, msg, to)

Here, out set_alarm basically leverages our 'schedule' package to repeat the timer at certain days interval.

Finally the "send_alarm" used by "set_alarm" is used to send the actual message:

    def send_alarm(self, msg, to):
        sender = SMSender()
        sender.authenticate_client()
        sender.provision_client()
        sender.send_sms(to, msg)
        print("Alarm successfully sent!")

The send_alarm uses the previously coded SMSender to send the message.
Finally wrap these three functions into a Repeater class and that's it!

Finally our main function looks like:

if __name__ == "__main__":

    repeat = Repeater()
    starting_date = datetime.today()
    repeat.add_repeat_sequence(date_from=starting_date, repeat_after_days=14, msg="Heyaaaaa!", \
        to="+61444444444")


    while True:
        schedule.run_pending()
        time.sleep(1)

This will successfully send us a "Heyaaaaa!" every 14 days starting today.

Hope you liked the post. This is only a simple skeleton to provide a gist. There's still a lot of space for proper error checking, code testing and good code design. Feel free to change the code in whatever way you'd find yourself using it! All you need to do is run it in a server somewhere where it can run uninterrupted.

Thanks a lot!

You can find the full version of the code here in my github.

Software Programming: Job VS. Passion

Emalp — Sat, 10 Nov 2018 10:04:11 +0000

There are a lot of different types and kinds of programmers: the newbie, the oldie, the money follower, the passionate blah blah blah. And there's a lot of reasons every programmer codes.
One question I'd like you to ask yourself is, why do you even code?

It's your job, you need money.
You love programming, so you just code.
You had friends doing CS in Uni so you just followed them.

There's uncountable.

I want to manifest my thought on how I went, my battle, depression and where I stand now.

I started out early (at 9 years old to be exact). I loved it! It was a whole world of unknown possibilities. There's being god, having the power of a whole creating in your hands. There's being the cool kid in school who just knows stuff. There's hacking your crush's computer so you top the league in stalking.

These things inspired me to become a programmer. As time turned out, I learnt more and more. Just when I thought I'm done, there was more to learn. After several years of learning and putting it into practice, life hit me. I had to get a job, feed myself, make a life out me. I was a stubborn kid and didn't want to get into any other profession rather than programming. It turned out really really hard for me.

Then I started thinking things. Why do I even program? With all this tension on getting a "programming" job, earning money, and becoming the best of what I was; all these things started killing me from inside.

Every time I sat down to code, there was just this thing on my mind, why am I doing this? Is there a need to do this? Can't I move on to do a completely different thing than what I'm doing now? I had no interest in programming at all. I was completely stuck on an infinite loop.

What had caught me has caught many other programmers in some point of their lives. What started out as my passion was completely ruined because I had to do this as an compulsion now because of the money I needed and treated programming more of a job that I hated rather than the passion I had that I loved.

Well, the good thing? It fades out! The job part and your passion part are like two sets in an intersection. They sometimes collide and sometimes are completely different. I think the main thing to do is to separate your work life with your personal life completely. This way you have your passion on one hand and your whole work load on the other.

Also another thing to note is: the work you do does not define you and is NOT in any way your identity. The more you start identifying yourself with the work you do, the more frustrations you'll have to face. So the best thing to do is to have your work and your personal life completely different from each other. This way I slowly got the coding charm back and now have mostly got rid of it. Organizing my personal projects and my work projects have been easier.

Hope it sheds light on anyone's life that's going through the same process and know that you're not alone. But rather every programmer has a "frustration" phase to go through and it passes out eventually.
Thanks.

Programming is more than just programming.

Emalp — Sat, 10 Nov 2018 08:59:52 +0000

I grew up smart because I started programming when I was just merely 9 and quickly grasped it. I considered myself to be a full fledged programmer after about 4 years of hard programming when I was about 13-14 years old. I had mastered JAVA, Visual Basic .net, PHP, Javascript and could smoothly navigate LINUX.
But I only got my first job after another 3 years of hard trying. I don't know if it was my age that restricted the companies to hire me or whether it was my skill that did not meet the criteria. Nevertheless, I was in no doubt of my programming skills, so there must be another reason behind me not getting a job for so long.

I had two things in mind.

Maybe it was my age that restricted me.
(I'll be explaining this is more detail.)

I had no control over my age so let's just forget it was even there.
The second thing I think that was opaque to me getting a job were a list of things more than "just programming". I was good at programming but I was missing something.

I'll list those things below. Also, I believe these are the things that are not/very less taught in universities while getting a bachelor's degree and the new grads have to learn it after they graduate and go through a lot of unnecessary trouble of learning.

Testing the code.
Yes, I did not test my code. Nothing. 0. All I did was a lot of print statements to know where my code fails. That's it. Testing the code and mainly nowadays Test Driven Development(TDD). Just do it even when you're only playing around with your own piece of code.
Learn your way through the debugger.
The debugger will be your best friend after you're tired with all the writing and commenting of your print statements in a lot of places. If you prefer NodeJS, there's node inspect, for C there's GDB. There always is a way to debug. Utilize it.
Design Patterns is more important than algorithms.
Yes, Universities and interviews tend to focus more on your knowledge on algorithms, logic and data structures but trust me, design patterns is all that's gonna count later. Unless you're working for big companies like Google and Facebook as an engineer; there's very less chance you'll actually implement your own algorithms or even code an already discovered algo. But you'll be making a lot of classes and modules. You'll need to manage them, create and manage new objects and also the directories you place your files in. Having a solid foundation for your directories and any new classes you create is a must.

Well, that's all. Hope it helps any new programmer. These are just my opinions on what set me back.
Thanks.
P.S This is my first post.