Shanky's Brainchild

Event report for DebUtsav Delhi 2019

2019-04-20T00:00:00+05:30

The Debian India Community in Delhi along with Mozilla Delhi/NCR community organized DebUtsav Delhi 2019 on 9 and 10 March, 2019.

For those who are unware, DebUtsav is an Indian style version of a typical Mini Debian Conference.

This was the first Debian related conference to be organized in the Northern region of India. We have had Mini Debian conferences previously in Mumbai, Pune, Hyderabad and in different cities of state of Kerala. But this was the very first one in the Northern Region.

DebUtsav was made possible with the help from our sponsors

Hamara Linux
National Institute of Public Finance and Policy
The travel costs of some of our speakers were generously covered by Debian.

The event took place at National Institute of Public Finance and Policy (NIPFP), Delhi.

The event schedule was divided into two tracks.

Debian Track and FOSS Track. The Debian Track was specific for the talks or workshops related to Debian.
The FOSS track included talks/workshops ranging from General Free Software, Gender Diversity a Digital Security and privacy. The full schedule is present on the website DebUtsav.in

On the first day of DebUtsav

Debian Track

Although you can check the talks happened at the talks in the link to schedule. Some of the notable talks were Pirate Praveen on Debian Packaging in times of Docker and Flatpak. Abhijit Introduced us to the Debian LTS project. While Raju Devidas talked on "How to become a Debian Developer?" There were also workshops by Utkarsh Gupta and Sagar Ippalpalli on Packaging of Ruby Gems and Node Modules.

FOSS Track

Ashutosh Singh, also known as Juggernaut, talked on getting started into Open Source and Debian. The other talks in FOSS track included, a talk on Cryptography & Cryptanalysis by Ishan Malik. While Mohit Phulera talked about Setting up and using Google Vision API's. Thing to note here that both were first time speakers. DebUtsav got them started. We also had a Rust 101 workshop by Swarnim Arun. Karmanya Talked about Building Data Apps with Grames. The last talk for the day in FOSS track was by Himanshu, it had a funky name to it, SELinux: For the Asgardians

Second Day of DebUtsav

Debian Track

The first talk of the day was on an Introduction to the Hamara Linux project by Shivani Bharadwaj and Raju Devidas. They introduced the Hamara Project to the one's present as well as talked about there upcoming release of Hamara codenamed Svastik.

Later in the Debian track, we had the first ever Bug Squashing Party BSP in India. For the BSP we had 2 DD's and 2 DM's and many other active Debian contributors present. They helped people present to go through the Debian bug tracking system BTS and find bugs that they can help solve. Although we did not manage to get any bugsolved during the duration of BSP, we did managed to get some people get familiar with Debian's bug tracking eco-system, introduced them to the various teams within Debian in which they can co-ordinate to get started for solving bugs as well as contributing to Debian in general. The BSP proved to be a good starting point for Utkarsh Gupta. Within two-three weeks after the BSP he has already solved many bugs including 15 RC bugs.

FOSS track

The first talk in the FOSS track was on Digital Security and Privacy by Shashikanth.

In the second talk our DM Sruthi Chandran raised the question on How gender diverse and inclusinve is the Free Software Community?. She co-ordinated the sicussion very well and made sure that the people present during the session got involved.

Later in the Day we had talks by Pirate Praveen on Take back our data and Freedoms. Vipul Gupta talked about digging Opportunities in Open Source. Last talk which was scheduled for the foss track did not take place because of the un-availability of the speaker Ranjith Raj Vasam. Everyone got involved into the Debian BSP instead.

On the sidelines of the schedule of the second day, the podcast team of Decompiled was also present. With the efforts of the team, Raju Devidas interviewed Pirate Praveen. In the interview they talked about work done by Praveen over the years as well as his journey in Debian project.

Some statistics from DebUtsav

For both the days combined, around 120 people registered for attending DebUtsav, out of them around 95 attended the conference.
Around 10-15, unregistered attendees/on spot registrations were also present.
We had a total of 14 Women Attendees.

DebUtsav Delhi was lucky to have the presence of - 2 Debian Developers Pirate Praveen & Abhijith PA. - 2 Debian Maintainers Sruthi Chandran and Sagar Ippalpalli.

It is during the conversations that happened at the conference that we realized that there are a lot of first's happening in the Debian India Community.

Sruthi Chandran is the first Women Debian Maintainer from India, also soon to be the first women Debian Developer from India.
Presence of DD's proved useful for Utkarsh Gupta as he got his initial requirements for a DM fulfilled with his keys signed by the DD's present at DebUtsav. He is at the time of writing this event report, the youngest DM from India.
Currently Sruthi Chandran and Raju Devidas have there DD applications in process. If they get approved, we will be crossing the Double Digits of DD's from India for the first time. They are 9 now and with two more we will get to 11.
This was the first Debian related conference in Delhi or anywhere in Northern India.

DebUtsav Delhi proved very productive in introducing many new people to Debian project and to free software in general. Also it provided an opportunity for the Debian contributors from Delhi to meet the Debian Developers.

The conference was made possible by the continuous efforts of people from the communities of Mozilla Delhi NCR and Indian Linux User's Group Delhi. Some of the people involved in the effort could be seen on the Team section of debutsav.in

Thanks a lot to everyone for puting up there efforts for DebUtsav Delhi. We are looking forward to having another Debian event in Delhi and more events around India.

Google Summer of Code 2018 with Debian - Final Report

2018-08-13T00:00:00+05:30

Three weeks of Google Summer of Code went off to be life-changing for me. This here is the summary of my work which also serves as my Final Report of Google Summer of Code 2018.

Preperations

My project is Wizard/GUI helping students/interns apply and get started and the final application is named New Contributor Wizard. It originated as the brainchild and Project Idea of Daniel Pocock for GSoC 2018 under Debian. I prepared the application task for the same and shared my journey through Open Source till GSoC 2018 in two of my blogs, From Preparations to Debian to Proposal and The Application Task and Results.

Project Overview

New Contributor Wizard is a GUI application build to help new contributors get started with Open Source. It was an idea to bring together all the Tools and Tutorials necessary for a person to learn and start contributing to Open Source. The application contains different courseware sections like Communication, Version Control System etc. and within each section, there are respective Tools and Tutorials.

A Tool is an up and running service right inside the application which can perform tasks to help the user understand the concepts. For example, encrypting a message using the primary key, decrypting the encrypted message using the private key, and so on, these tools can help the user better understand the concepts of encryption.

A tutorial is comprised of lessons which contain text, images, questions and code snippets. It is a comprehensive guide for a particular concept. For example, Encryption 101, How to use git?, What is a mailing list? and so on.

In addition to providing the Tools and Tutorials, this application is build to be progressive. One can easily contribute new Tutorials by just creating a JSON file, the process of which is documented in the project repository itself. Similarly, a documentation for contributing Tools is present as well.

Project Details

GSoC Project Page - GSoC Projects #5056989357408256
Project Respository - New Contributor Wizard on Debian Salsa
Issue/Bug Tracker - New Contributor Wizard on Debian Redmine
Communication - Private thread with mentors for daily updates, Debian Outreach Mailing List for weekly updates and Jitsi Meet for conference calls.

Programming Language and Tools

For Development

For Testing

Environment

Pipenv for Python Virtual Environment
Debian 9 for Project Development and testing

Version Control System

For pinned dependencies and sub-dependencies one can have a look at the Pipfile and Pipfile.lock

My Contributions

The project was just an idea before GSoC and I had to make all the decisions for the implementation with the help of mentors whether it was Design or Architecture of the application. Below is the list of my contributions in shape of merge requests and every merge request contains UI, application logic, tests, and documentation. My contributions can also be seen in Changelog and Contribution Graph of the application.

Sign Up

Sign Up is the first screen a user is shown and asks for all the information required to create an account. It then takes the user to the Dashboard with all the courseware sections.

Merge request - Adds SignUp feature

Redmine Issue - Create SignUp Feature

Feature In Action (updated working of the feature)

Your browser does not support HTML5 video.

Sign In

Alternate to Sign Up, the user has option to select Sign In to use existing account in order to access the application.

Merge Request - Adds SignIn feature

Redmine Issue - Create SignIn Feature

Feature In Action (updated working of the feature)

Your browser does not support HTML5 video.

Dashboard

The Dashboard is said to be the protagonist screen of the application. It contains all the courseware sessions and their respective Tools and Tutorials.

Merge Request - Adds Dashboard feature

Redmine Issue - Implementing Dashboard

Feature In Action (updated working of the feature)

Your browser does not support HTML5 video.

Adding Tool Architecture

Every courseware section can have respective Tools and Tutorials. To add Tools to a section I devised an architecture and implemented on Encryption to add 4 different Tools. They are:

Create Key Pair
Display and manage Key Pair
Encrypt a message
Decrypt a message

Merge Request - Adding encryption tools

Redmine Issue - Adding Encryption Tools

Feature In Action (updated working of the feature)

Your browser does not support HTML5 video.

Adding Tutorial Architecture

Similar to Tools, Tutorials can be found with respect to any courseware section. I have created a Tutorial Parser, which can take a JSON file and build GUI for the Tutorial easily without any coding required. This way folks can easily contribute Tutorials to the project. I added Encryption 101 Tutorial to showcase the use of Tutorial Parser.

Merge Request - Adding encryption tutorials

Redmine Issue - Adding Encryption Tutorials

Feature In Action (updated working of the feature)

Your browser does not support HTML5 video.

Adding 'Invite Contributor' block to Tools and Tutorials

In order to invite the contributor to New Contributor Wizard, every Tools and Tutorials menu display an additional block by linking the project repository.

Merge Request - Inviting contributors

Redmine Issue - Inviting contributors to the project

Feature In Action (updated working of the feature)

Your browser does not support HTML5 video.

Adding How To Use

One of the courseware section How To Use help the user understand about different sections of the application in order to get the best out of it.

Merge Request - Updating How To Use

Redmine Issue - Adding How To Use in the application

Feature In Action (updated working of the feature)

Your browser does not support HTML5 video.

Adding description to all the modules

All the courseware sections or modules need a simple description to describe what the user will learn using it's Tutorials and Tools.

Merge Request - Description added to all the modules

Redmine Issue - Add a introduction/description to all the modules

Feature In Action (updated working of the feature)

Your browser does not support HTML5 video.

Adding Generic Tools and Tutorials Menu

This feature allows the abstraction of Tools and Tutorials architecture I mentioned earlier so that the Menu architecture can be used by any of the courseware sections following the DRY approach.

Merge Request - Adding Generic Menu

Redmine Issue - Adding Tutorial and Tools menu to all the modules

Tutorial Contribution Doc

A tutorial in the application can be added using just a JSON file. As mentioned earlier, it is made possible using the Tutorial Parser. A comprehensive ocumentation is added to help the users understand how they can contribute Tutorials to the application for the world to take advantage of.

Merge Request - Tutorial contribution docs

Redmine Issue - Add documentation for Tutorial development

Tools Contribution Doc

A tool in the application is build using Kivy lang and Python. A comprehensive documentation is added to the project in order for folks to contribute Tools for the world to take advantage of.

Merge Request - Tools contribution docs

Redmine Issue - Add documentation for Tools development

Adding a License to project

After having discussions with the mentors and a bit of research, GNU GPLv3 was finalized as the license for the project and has been added to the repository.

Merge Request - Adds License to project

Redmine Issue - Add a license to Project Repository

Allowing different timezones during Sign Up

Merge Request - Allowing different timezones during signup

Redmine Issue - Allow different timezones

All other contributions

Here's a list of all the merge request I raised to develop a feature or fix an issue with the application - All merge request by Shashank Kumar

Here are all the issues/bug/features I created, resolved or was associated to on the Redmine - All the redmine issue associated to Shashank Kumar

Packaging

The application has been packaged for PyPi and can be installed using either pip or pipenv.

Package - new-contributor-wizard

Packaging Tool - setuptools

To Do List

Weekly Updates And Reports

These report were send daily to private mentors mail thread and weekly on Debian Outreach mailing list.

Talk Delivered On My GSoC Project

On 12th August 2018, I gave a talk on How my Google Summer of Code project can help bring new contributors to Open Source during a meetup in Hacker Space, Noida, India. Here are the slides I prepared for my talk and a collection of photographs of the event.

Summary

New Contributor Wizard is ready for the users who would like to get started with Open Source as well as to the folks who would like to contribute Tools and Tutorials to the application as well.

Acknowledgment

I would like to thank Google Summer of Code for giving me the opportunity of giving back to the community and Debian for selecting me for the project.

I would like to thank Daniel Pocock for his amazing blogs and ideas he comes up which end up inspiring students and result in a project like above.

I would like to thank Sanyam Khurana for constantly motivating me by reviewing every single line of code which I wrote to come up with the best solution to put in front of the community.

Thanks to all the loved ones who always believed in me and kept me motivated.

Google Summer of Code 2018 with Debian - Week 5

2018-06-20T00:00:00+05:30

During week 5, there were 3 merge requests undergoing review process simultaneously. I learned a lot about how code should be written in order to assist the reader since the code is read more times than the time it is written.

Services and Utility

After the user has entered their information on the signin or signup screen, the job of querying the database was given to a module named updatedb. The job of updatedb was to clean user input, hash password, query the database and respond with appropriate result after the database query is executed. In a discussion with Sanyam, he said updatedb doesn't conform to its name with what functions it incorporated. And explained the virtue of Service and Utility modules/functions and that this is the best place to restructure code with the same.

Utility functions can be described roughly as the functions which perform some operations on the data without caring much about the relationship of the data with respect to the application. So, generating uuid, cleaning email address, cleaning full name and hashing password becomes out utility functions and can be seen in utils.py for signup and similarly for signin.

Service functions can be described roughly as the functions which while performing operations on the data take their relationship with the application into account. Hence, these functions are not generic and application specific. sign_up_user is one such service function which received user information, calls utility functions to modify that information, query the database with respect to the signup operation i.e. adding the new user's detail to the database or raise SignUpError if details are already present. This can be seen in services module for signup and signin as well.

Persisting database connection

This is how the connection to the database used to work before the review. The settings module used to create the connection to the database, create table schema if not present and close the connection. Few constants are saved in the module to be used by signup and signin in order to connect to the database. But, the problem is, now database connection has to be established everytime there's a query to be executed by the services of signup or signin. Since the sqlite3 database is saved in a file alongside the application, I though it'll not be a problem to make connection whenever needed. But it overhead on the OS now which can slow down the application when scaled. To resolve this, now settings return the connection object which can be used again in any other module.

Integrating SignUp with Dashboard

While the SignUp feature was being reviewed the Dashbaord was merged and I had to refactor SignUp merge request accordingly. The natural flow of this should be the SignUp being the default screen up on the UI and after successful signup operation the Dashboard should be displayed. To achieve such a flow, I used screen manager which handles different screens and transition between them with predefined animation. This is defined in main module and the entire flow can be seen in action below.

Your browser does not support HTML5 video.

Designing Tutorials and Tools menu

Once user is on the Dashboard, they have an option of picking up from different modules and going through the tutorials and tools available in the respective modules. The idea is to display difficulty tip as well so it becomes easier for the user to begin. Hence, below is what I've designed in order to incorporate the same.

Implementing Tutorials and Tools menu

Now comes the fun part, thinking about the architecture of the modules just designed in order for them to take shape of some code in the application. The idea here is to define them in a json file to be picked from the respective module afterwards. This way it'll be easier to add new tutorials and tools and hence we have this resultant json. The developement of this feature can be followed on this merge request

Now remains the quest to design and implement the structure of tutorials which can be generalized in a way that it can be populated using a json file. This will provide flexibility to the developer of tutorials and a UI module can also be implemented to modify this json to add new tutorials without even knowing how to code. Sounds amazing right? We'll see how it works out soon. If you have any suggestions this make sure to comment down below, on the merge request or reach out to me.

The Conclusion

Since the SignUp has also been merged I'll have to refactor SignIn now to integrate all of it in one happy application and complete the natural flow of things. Also, the design and development of tools/tutorials is underway and by the next blog is out you might be able to test the application with atleast one tool or tutorial from one of the modules on the dashboard.

Google Summer of Code 2018 with Debian - Week 4

2018-06-12T00:00:00+05:30

After working on designs and getting my hands dirty with KIVY for the first 3 weeks, I became comfortable with my development environment and was able to deliver features within a couple of days with UI, tests, and documentation. In this blog, I explain how I converted all my Designs into Code and what I've learned along the way.

The Sign Up

In order to implement above design in KIVY, the best way is to write a user kv-lang. It involves writing a kv file which contains widget tree of the layout and a lot more. One can learn more about kv-lang from the documentation. To begin with, let us look at the simplest kv file.

BoxLayout:
    Label:
        text: 'Hello'
    Label:
        text: 'World'

KV Language

In KIVY, in order to build UI widgets are used. Also, widget base class is what is derived to create all other UI elements like layouts, button, label and so on in KIVY. Indentation is used in kv just like in Python to define children. In our kv file above, we're using BoxLayout which allows us to arrange all its children in either horizontal(by default) or vertical orientation. So, both the Labels will be oriented horizontally one after another.

Just like children widgets, one can also set values to properties like Hello to text of the first Label in above code. More information about what properties can be defined for BoxLayout and Label can be seen from their API documentaion. All which remains is importing this .kv (say sample.kv) file from your module which runs KIVY app. You might notice that for now Language and Timezone are kept static. The reason is, Language support architecture is yet to be finalized and both the options would require a Drop Down list, design and implementation for which will be handled separately.

In order for me to build the UI following the design, I had to experiment with widgets. When all was done, signup.kv file contained the resultant UI.

Validations

Now, the good part is we have a UI, the user can input data. And the bad part is user can input any data! So, it's very important to validate whether the user is submitting data in the correct format or not. Specifically for Sign Up module, I had to validate Email, Passwords and Full Name submitted by the user. Validation module can be found here which contains classes and methods for what I intended to do.

It's important that user gets feedback after validation if something is wrong with the input. This is done by exchanging the Label's text with error message and color with bleeding red by calling prompt_error_message for unsuccessful validation.

Updating The Database

After successful validation, Sign Up module steps forward to update the database in sqlite3 module. But before that, Email and Full Name is cleaned for any unnecessary whitespaces, tabs and newline characters. Universally unique identifier or uuid is generated for the user_id. Plain text Password in changed to sha256 hash string for security. Finally, sqlite3 is integrated to updatedb.py to update the database. SQlite database is stored in a single file and named new_contributor_wizard.db. For user information, the table named USERS is created if not present during initialization of UpdateDB instance. Finally, information is stored or error is returned if the Email already exists. This is how the USERS schema looks like.

id VARCHAR(36) PRIMARY KEY,
email UNIQUE,
pass VARCHAR(64),
fullname TEXT,
language TEXT,
timezone TEXT

After the Database is updated, i.e. successful account creation of user, the natural flow is to take the user to the Dashboard screen. In order to make this feature atomic, integration with Dashboard would be done once all 3 (SignUp, SignIn, and Dashboard) features are merged. So, in order to showcase successful sign-up, I've used text confirmation. Below is the screencast of how the feature looks and what changes it makes in the database.

Your browser does not support HTML5 video.

The Sign In

If you look into the difference in UI of SignIn module in comparison with the SignUp, you might notice a few changes.

The New Contributor Wizard is now right-aligned
Instead of 2 columns taking user information, here we have just one with Email and Password

Hence, the UI experiences only a little change and the result can be seen in singin.py.

Validations

Just like in the Sign Up modules, we are not trusting user's input to be sane. Hence, we validate whether the user is giving us a good format Email and Password. The resultant validations of Sign In modules can be seen in validations.py.

Updating The Database

After successful validation, next step would be cleaning Email and hashing the Password entered by the user. Here we have two possibilities of unsuccessful signin,

Either the Email entered by the user doesn't exist in the database
Or the Password entered by the user is not correct

Else, the user is signed in successfully. For the unsuccessful signin, I have created a exceptions.py module to prompt the error correctly. updatedb.py contains the database operations for Sign In module.

The Exceptions

Exceptions.py of Sign In contains Exception classes and they are defined as

UserError - this class is used to throw an exception when Email doesn't exist
PasswordError - this class is used to throw an exception when Password doesn't match the one saved in the database with the corresponding email.

All these modules are integrated with signin.py and the resultant feature can be seen in action in the screencast below. Also, here's the merge request for the same.

Your browser does not support HTML5 video.

The Dashboard

The Dashboard is completely different than the above two modules. If New Contributor Wizard is the culmination of different user stories and interactive screen then Dashboard is the protagonist of all the other features. A successful SignIn or SignUp will direct the user to the Dashboard. All the tutorials and tools will be available to the user henceforth.

The UI

There are 2 segments of the Dashboard screen, one is for all the menu options on the left and another is for the tutorials and tools for the selected menu option on the right. So, it was needed to change the screen on the right all the time while selecting the menu options. KIVY provides a widget named Screen Manager to manage such an issue gracefully. But in order to have control over the transition of just a part of the screen rather than the entire screen, one has to dig deep into the API and work it out. Here's when I remembered a sentence from the Zen of Python, "Simple is better than complex" and I chose the simple way of changing the screen i.e. by adding/removing widget functions.

In the dashboard.py, I'm overidding on_touch_down function to check which menu option the user clicks on and calling enable_menu accordingly.

The menu options on the left are not the Button widget. I had an option of using the Button directly but it would need customization to make them look pretty. Instead, I used BoxLayout and Label to incorporate a button like feature. In enable_menu I only check on top of which option user is clicking using the touch API. Now, all I have to do is highlight the selected option and unfocus all the other options. The final UI can be seen here in dashboard.kv.

Courseware

Along with highlighting the selected option, Dashboard also changes to the courseware i.e. tools and tutorials for the selected option on the right. To provide a modular structure to application, all these options are build as separate modules and then integrated into the Dashboard. Here are all the modules for the courseware build for the Dashboard,

blog - Users will be given tools to create and deploy their blogs and also learn the best practices.
cli - Understanding Command Line Interface will be the goal with all the tutorials provided in this module.
communication - Communication module will have tutorials for IRC and mailing lists and showcase best communication practices. The tools in this module will help user subscribe to the mailing lists of different open source communities.
encryption - Encrypting communication and data will be tough using this module.
how_to_use - This would be an introductory module for the user for them to understand how to user this application.
vcs - Version Control Systems like git is important while working on a project whether personal or with a team and everything in between.
way_ahead - This module will help users reach out to different open source communities and organizations. It will also showcase open source project to the user with respect to their preference and information about programs like Google Summer of Code and Outreachy.

Settings

Below the menu are the options for settings. These settings also have separate modules just like courseware. Specifically, they are described as

application_settings - Would help out user to manage setting which are specific to KIVY application like resolutions.
theme_settings - User can manage theme related setting like color schema using this option
profile_settings - Would help the user manage information about themselves

The merge request which incorporates the Dashboard feature in the project can be seen in action in the screencast below.

Your browser does not support HTML5 video.

The Conclusion

The week 4 was a bit satisfying for me as I felt like adding value to the project with these merge requests. As soon as the merge requests are reviewed and merged in the repository, I'll work on integrating all these features together to create a seamless experience as it should be for the user. There are few necessary modifications to be made in the features like supporting multiple languages and adding the gradient to the background as it can be seen in the design. I'll create issues on redmine for the same and will work on them as soon as integration is done. My next task would be designing how tutorials and tasks would look in the right segment of the Dashboard.

Google Summer of Code 2018 with Debian - Week 3

2018-06-04T00:00:00+05:30

Coming to the third week of GSoC felt like it was part of the daily schedule since ever. Daily updates to mentors, reviews, and evaluations on merge/pull requests and constant learning process kept my schedule full of adrenalin. Here's what I worked on!

How A Project Is Made with Sanyam Khurana

Building an idea into a project seems like a lot of work and excitement right? You can do all sorts of crazy stuff with your code to make it as amazing as possible. Use all sorts of cool-tool in hope of making something out of it at the end. But this is where the problem lies. Diving into the sea of amusement and uncertainty never promises a good ending. And hence, my mentor Sanyam Khurana and I sat down for my intervention in hope of structuring the tasks for good. And this is how a project begins. Sanyam with his experience in Open Source as well as industry taught me the importance of dividing tasks which should be atomic and should clearly define what we are trying to achieve in Plain-English. For example, when you are trying to make a blogging website, you don't create a pull request with all of the functionalities needed for the blog. First, think about the atomic tasks which can be done independently. Now create a series of these tasks (we call them tickets/issues/features). So, you have a ticket for, say, setting up pelican blog. Another for creating a theme for your blog. Another for adding analytics to your blog and so on.

Now, you can also create boards or table with columns which define the state of which these tasks lies. A task may be in development or in testing or review phase. This makes it easier to vizualise what needs to be done, what has been done already and what tasks should be in focus currently. This methodology in a broader sense and proper framework with a lot of disciplines in action is known as Agile Software Development.

Dividing Project into Tasks

After learning much about how to proceed, I sketched out the way in which I can separate out the atomic features needed for the project. We're using Debian hosted Redmine for our project management and I started jotting down the issues, to begin with. Here are the issues which shape the beginning of the project.

Create Design Guideline - The first issue in order to create a reference GUI design guideline for the application.
Design GUI for Sign Up - Design mockup following the guideline to describe how Sign Up module should look like on the GUI.
Design GUI for Sign In - Design mockup following the guideline to describe how Sign In module should look like on the GUI.
Create Git repository for the project - Project mentor Daniel created this issue as the first step which marks the beginning of the project.
Initializing skeleton KIVY application - After a dedicated repository has been created for our project, a KIVY application has to be setup which should also include tests, documentation, and changelog.
Create SignUp Feature - After the skeleton is setup, sign up modules can be implemented which should present a GUI to the user in order to create the account to access the application. This screen should be the first interaction with the user after they run the application for the first time.
Create SignIn Feature - If the user is already signed up for an account on the application, this screen will be the medium with which they can Sign In with the credentials.
Add a license to Project Repository - Being an open source project, picking up license is a very elaborative process where we have to also look at all the dependencies our application has and other parameters. Hence, this issues is more of a discussion which will conclude by adding a License file in the project repository.

These were some of the key issues which came up after my discussion with Sanyam (except creating git repo which Daniel kickstarted). These issues were enough to begin with and as we progress we can create more issues on Redmine. As part of the first couple of weeks of GSoC, I've already completed the first 3 design issues, I also wrote a blog explaining about my process and the outcome. So, for the third week, I started with initializing skeleton KIVY application.

The First Merge Request

Don't be confused if you are a Github native, since we are using Debian hosted Gitlab (called salsa), it has Merge Request in place of Pull Request.

The issue which I was trying to solve in my first Merge Request was Initializing skeleton KIVY application. It was just to create a boilerplate from scratch so that development from now on would be smooth. I set out to achieve following things in my Merge Request

Add a KIVY application which can create a sample window with sample text on it to showcase that KIVY is working just fine
Create the project structure to fit documentation, ui, tests and modules
Add pipenv support for virtual environment and dependency management
Integrate pylint to test Python code for PEP8 compliance
Integrate pytest and write tests for unit and integration testing
Adding Gitlab CI support
Add a README.md file and write general description about the project and all it's components
Add documentation for end user to help them easily run and explain all the features of the application
Add documentation for developers to help them build the application from source
Add documentation for contributors to share some of the best practices while contributing to this application

Here's the Merge Request which resulted in all of the above additions to the project. It was a lot of pain getting CI to work for the first time, but once you get a green tick, you know what ticks CI to work correctly. Throughout my development process Sanyam helped me with reviews and it finally got merged into the repository by Daniel.

Conclusion

This week kickstarted the main development process for New Contributor Wizard and gave me a chance to learn about project/software management. I will be creating more issues and share about what I'm working in the next week's GSoC blog.

Google Summer of Code 2018 with Debian - Week 1 and 2

2018-05-28T00:00:00+05:30

After I got the news of my selection in Debian for Google Summer of Code program, I've been exploring different domains in which one can contribute to Debian and hence making the community bonding phase as productive as it can get.

Community Bonding

For Debian, Mailing Lists are one of the primary means of communication among the contributors and maintainers of the community. It was also stated on the Debian's GSoC projects page that we students should be joining debian-outreach, debconf-announce, debian-announce and debian-devel-announce lists. debian-outreach list is for the communications mostly related Gooogle Summer of Code, Rail Girls Summer of Code and similar programs. One can always find lists as per their interests from the Debian Mailing Lists index.

Similarly, #debian-outreach and #debconf-discuss are the IRC few of the Debian IRC channels which were recommended. And is mostly filled with valuable conversations to follow. Even if you don't know where to begin in order to contribute, simply ask!

Before the Coding Phase, we had a Jitsi call with the mentors and students under one room in order to discuss and plan ahead. We also agreed on having a weekly call in the same room, the schedule for which was carefully picked up which took everyone's timezone into account. Sanyam Khurana, who is one of my mentors for this project is the only person I've known among all my mentors and fellow students from before. I've been learning from his work since we started meeting during meetups in Delhi NCR and he's generous enough to spare additional hours from his day in which we can meet and have healthy discussions about the project.

Design - The Beginning Of Everything

Since we are 3 folks working on the same project, mentors had a very important task of dividing modules among students which had to be atomic. Modules which were allocated were not final and open to discussion. These modules only gave an idea about the feature to be implemented, it's up to the student to plan accordingly with the help of the mentors and proceed with actual implementation. I began with working on the Design of the application.

Design Guidelines - The Palette

I like Coolors and have been using it for quite some time now. It's a go-to tool when you are exploring color palette for your project. I explored a bit and decided to go with 4 colors. 2 Solids and 2 variants of the original colors of my choice which can be seen below. Then I decided to pick fonts for the application from Google Fonts as it provides all the proper guidelines for the different use cases and licensing. I went ahead with Anton and Varela Round, both of which come with an Open Font License. I've also shared the raw SVG design in the blog which we'll also be using for our development process. In order for the font in the SVG to work, simply download both the fonts mentioned above and install them in your OS's font directory.

SVG Version of the above poster to play can be found here.

Design Guidelines - The Gradient

While contributing to Open Source Projects and Communities, it's important to embrace it with the rich history and resources they have given us mostly with a Go-Nuts license. This is the reason why I chose Inkscape for all my designing work. The beauty of picking up variants of colors is you can mix and match them in order to create beautiful gradients. So, I did! I used the two variants of the Blueish-like color selected earlier and created the gradient which can be seen below. The gradient is linear and two colors are selected for horizontal ends of the box.

Now to create the main dashboard, I just needed a little imagination about which end point would be best for which gradient and here's the result. SVG version to play can be found here.

GUI - The Sign Up

Sign Up will probably be the first screen the user encountered on the application after installation. Here, user shares few important details about themselves which will be used to create an instance and persist user activity throughout the application. Using the same Dashboard I created the Sign Up screen as seen below. SVG version to play can be found here.

Additionally, I used Down Arrow Icon and Eye Icon in the design both of which are licensed with Creative Commons.

GUI - The Log In

After when the user has signed up, they can Log In henceforth using their email address and password shared during the Sign Up process. You might notice that the partition between the Blackish and Blueish segment changes size between Sign Up and Log In. It would look cool if we are able to animate the size when user switches between the screens. SVG version to play of the Log In design can be found here.

GUI - The Dashboard

Finally, after the user is authenticated, they are taken to the main screen of the application I'm calling Dashboard. On the Dashboard, one can find all the tutorials for the technology or concept available and also the tools mentioned. I extended the design to include a panel on the left segment. This panel contains options to view and modify configurations for the application. The Profile Icon can be used to give user option to change details about themselves. The Paint Icon can be used to allow the user to change the application theme. The Gear Icon can be used to provide additional application specific settings like language choice, updates etc. SVG version to play of the design below can be found here.

Conclusion

These designs will now be used to implement the GUI of the application. The designs are open to modification to fit the need of the application. We're using a Debian hosted Redmine to manage our project and I've created few issues to implement design in code with proper tests and documentation. This is the highlight of what I've been doing for the first couple of weeks and I'll continue to share updates via my blog in future as well.

PyDelhi Dev Sprints - 28th April 2018

2018-05-03T00:00:00+05:30

The Idea

Rajat Saini who is one of the PyDelhi volunteers for a long time suggested new concepts for PyDelhi events on the mailing list. Discussions began both on the mailing list and on telegram volunteer group about the same and we planned to organize PyDelhi Dev Sprint on April 28th. Begin one of the volunteers I had the responsibility of creating a form for organizations and mentors, reaching out to them and also broadcast the news to different FOSS communities in and around Delhi.

The Organisations

Close to the event date, we had following organizations confirmed for Dev Sprint.

Kivy - Akshay Arora
Coala - Hemang Kumar and Rahul Jha
Mozilla - Sanyam Khurana for AddOn Server, Remo and Mozilla Central and I, Shashank Kumar for AddOn Frontend
Python - Sanyam Khurana for CPython

The Day of Dev Sprints

Knowlarity invited PyDelhi to host Dev Sprint in their Gurugram office and also sponsored lunch afterward. It all began with a quick introduction from everyone and Sanyam taking a session on what Dev Sprints actually are. Later, the attendees chose their projects and circled around the mentors for the same. Those who were new to Git and Github were helped by Priyank who took the initiative of teaching VCS. Afterward, Knowlarity CTO, Ajay Shrivastava took a quick inspirational session and then Hiring and Pitching session took place.

The Aftermath

The result of the event was 11 Issues and 6 Pull Requests to different project of participating organizations and listed them on etherpad. Folks who contributed got PyDelhi and Github swags. We took a mandatory group picture afterward to conclude the day. Hope to see you guys in upcoming PyDelhi Meetup

Google Summer of Code 2018 - Blog 2 - The Application Task and Results

2018-04-30T00:00:00+05:30

In my earlier blog Google Summer of Code 2018 - Blog 1 - From Preparations to Debian to Proposal, I shared few highlights from my life which inspired me to learn Python and taught me good programming practices in general. And how I got to know about Google Summer of Code program and completed my final proposal for Debian. In this blog, I'll share about the application task which was to be completed alongside the proposal.

Application Task - Introduction

I started with probing through GSoC 2016 organizations and their mailing lists, wikis and blogs to find out whether they are preparing for this year as well. For some of them, I was already aware as I have been contributing to upstream projects of these organizations on Github as well. Also, I was learning about Web Extensions while the process and also gave a talk for Mozilla in Aligarh Muslim University. So, I got interested when I saw that 2 of the project ideas from Debian lies in the domain of creating browser extensions. I chose to work on one of the ideas which needed me to create an extension which is not supported in newer browsers because of the lack of web extension support on their source code. I tried to wrap my head around the idea and because I could not find proper documentation on legacy code or a mentor in given time, I had to pivot to another idea.

This is when I saw Wizard/GUI helping students/interns apply and get started by mentor Daniel Pocock and because of my love for Python, I chose to work on this idea, preparing Proposal and Application Task. The idea was to provide all the tools of trade necessary for open source contribution with tutorial and references.

Application Task - Design

I thought of a rough roadmap of what I wanted to achieve through the application task both Graphical (on UI end) and Operational (on functional end). For the UI, I thought of providing a nice sidebar with options of changing through topics and main screen where the content would appear on the chosen topic. So I set out to create the design on Inkscape using Ubuntu Design Guidelines. Here's what I ended up with

In the above design, you can see sidebar containing menu on the left-hand side. I have placed the menu options based on their increasing difficulty of understanding. On the right-hand side, you can see the main screen currently showing content from the selected option on the left. Right now it is showcasing 'Communication' which can be a segment in which users will understand the importance of Mailing list and IRC. There can also be an option of subscribing to Mailing Lists or channels on IRC via the software itself.

In another design above, you can see a user is underway leaning how Command Line Interfaces work with UNIX commands. To make it more interactive, the user can be asked to perform certain tasks like running a command on the terminal and submitting output in order to proceed to next level.

Application Task - Implementation

In the project idea, Daniel mentioned the use of PyQt in order to work on the application task, so I did. PyQt5 was the latest of the stable version of PyQt which can be used and from the official documentation, it was said to be more 'Pythonic' than it's predecessor PyQt4. Also, I found a very good tutorial by Jan Bodnar on ZedCode which helped me understand the basics of PyQt5 API before I can take help from official documentation.

According to project idea, I had to implement any one of the features for which I choose to work with PGP keys. The user would be able to manage their PGP keys pairs i.e. creating, exporting, encrypting and decrypting messages using PGP keys. After I was done, this is what the application task, which I named "Open Source Buddy" can do

Your browser does not support HTML5 video.

Daniel also suggested some of the FOSS tools and platform which we should be using for the development of the application. Following the guidelines, I used Salsa, which is a self-hosted GitLab on Debian server to host the application task. The entire source code with designs and demo video can be seen here.

This was just one of the functionalities and workflow which I proposed in my Final GSoC Proposal) to Debian.

GSoC 2018 - Results

As promised by GSoC on Twitter, results were announced on 23rd April 2018 at 9:30 IST (16:00 UTC). With marginally less breath and heartbeats I went on to the official website to checkout the results. And there it was!

My proposal got accepted for Debian, I for Google Summer of Code 2018 and the website confirmed it with my username and other details. I also received an official mail from Google regarding the same with other details regarding the program. I'm very excited about the journey and would be sharing what I learn and accomplish along the way. I would like to thank all the mentors who chose me for the responsibility of completing the project.

Google Udacity Scholarship and getting my idea selected for Collaborative Projects

2018-04-09T00:00:00+05:30

About The Scholarship

Google Udacity Scholarship was the initiative under Google's Reskilling India Program and was announced during January 2018. I submitted my application with a hope of joining Intermediate Web Development Nanodegree Program i.e. Mobile Web Specialist. The news came in on 8th February that I was selected for the course and the courseware will be accessible on and after 14th February.

Course So Far

I have been hearing about Progressive Web Apps a lot (which is the focus of this program) and mostly from the JSLovers meetups. Udacity course gave me a chance to explore more in a systematic way through the courseware. Alongside the courseware, we're introduced to Discourse and Slack, specific to our program through which we could communicate with folks taking the same program under the scholarship. Best thing Udacity courses is that you are free to explore at your own time and pace.

Courseware began with showcasing what problems a website faces on a slow network (like a blank screen while page loading) and what are the ways in which these issues can be gracefully handled. Starting from the Service Worker, courseware explores all the essential APIs which can be used to achieve a Progressive Web App converting a simple website into one. It's been a very enriching experience learning from the videos and example projects.

Collaborative Project

When you work on projects relative to technologies you've been learning, it gives the complete sense of technology's behavior in the production environment which is essential. Akshit Jain, our moderator broke the news that we'll be working on collaborative projects soon and invited ideas from the participants on what they would like to work on. Selected ideas would become the projects everyone else will be contributing to and folks who have submitted the idea will moderate the project. You can find more information about what Collaborative Projects mean for the participants from the main announcement.

My Idea - Offline Bucket

My idea was to create a FOSS marketplace/dashboard for offline projects, I planned to name it Offline Bucket. Like Codepen or Kickstarter showcases projects, Offline Bucket would allow developers to submit their offline projects and more information regarding supported browsers, versioning and contribution guidelines if the project is Open Source. Here are some of the mockups I created for submission.

Splash Screen

Login/Signup Screen

Login Screen

SignUp Screen

Showcase Screen

Results

Final results came in and the 5 collaborative projects which were accepted are, Scholarships Projects Showcase App, Notes App, Udacity Pathfinder PWA, Blood Donation App and Guess the Quote. Reason being, ideas which matches were bundled in single projects and all the folks whose ideas were considered were made moderators. Hence, Offline Bucket became Scholarships Projects Showcase App and me, moderator alongside Shashikant Jha and Manoj Bahuguna for the same project. Being a moderator we need to further select co-moderators who'll handle specific tasks and contributors like UI/UX design, backend development. Soon there'll be a repository probably open sourced which will allow other participants to contribute. There's no constraint on how many projects one participant can contribute to.

I hope you get an idea of what this scholarship means and how exciting it is for the folks who get selected. If you did not get the chance of being a part of the program this year, make sure you look for future announcements. Also, you can apply for the next iteration of the program directly from Udacity.

Google Summer of Code 2018 - Blog 1 - From Preparations to Debian to Proposal

2018-03-31T00:00:00+05:30

I got to know about Open Source and community efforts during my first PyDelhi meetup close to a couple of years ago. And my journey began right from there. So in order to understand my preparation for GSoC, everything that has impacted me over the last couple of years is important. Here in this blog, I share what I learned to be able to work for the idea posted by Debian and submitting proposal afterward.

PyDelhi - The Beginning

After starting with Python I came across the community named PyDelhi which promotes Python programming language by organizing meetups and conferences. It is entirely volunteer-run and I also became active after attending my first ever meetup. One of the best Python books I was recommended by few folks was Python for You and Me by Kushal Das. I met folks who were working on cool projects using Python and I created one myself for PyDelhi named PyDelhi Bot to serve Telegram Volunteer Group. Later, I went on to give a talk during PyDelhi Conference 2017 which landed on YouTube and I have been a volunteer, speaker, contributor and co-organizer for PyDelhi ever since. I volunteered for PyCon India 2016, was in Core Organizing team for 2017 and volunteering for 2018 as well. My love for Python grew from PyDelhi and it became my primary programming language. Soon, I met various communities promoting Open Source software and methodologies and volunteered for them as well.

Durgapur Linux User Group - Summer Training

After looking more into Kushal Das' blog, I got to know about DGPLUG. DGPLUG organizes one of the best summer training which I was blessed to be a part of in 2016 and later in 2017 (to fill knowledge gaps). Training was carried on IRC which is always better so that folks with not-so-good internet reception can also benefit. The training started assuming everyone should learn from Zero and teaches all the basics following the objectives which a developer should know in order to write code and contribute to open source in the best way possible. Guest sessions were one of the important sessions in which we got to interact with community veterans and industry leaders. Guests shared their experiences with the technologies they were working on and we can ask them questions if we had any doubt regarding it. The entire session was recorded and the logs were uploaded for someone who couldn't be online.

During the training, some important things which I learned were by the Shakti Kanan sessions as follows

Communication Guidelines - I got to know about various communication platforms like IRC and Mailing Lists and what are the advantages and disadvantages of each of them has. It was important to learn when should be using those and how. Logs to session in which it was discussed.
Mailing List Etiquette - In this session, I got to learn what are the suggested ways in which we should be using Mailing Lists and proper format to draft mails. Logs to session in which it was discussed.
I Want To Do Project, Tell Me What To Do - Another important session to teach what are the ways in which we should start working on a project of our own or contribute to upstream projects. This tells us the importance of a mentor and how we can find one for ourselves. Logs to session in which it was discussed.

This was a fresh start for me in the path of becoming a good developer. This opened a lot of new ways to interact and collaborate with Open Source communities around the world. (If above links to presentation doesn't work use these - Communication Guidelines, Mailing List Etiquette and I Want To Do Project, Tell Me What To Do)

Google Summer of Code - Before The Proposal

Google Summer of Code has been an exciting opportunity for the folks willing to contribute to upstream Open Source projects and being my first and last (I graduate this year) time participating, I'm willing to work with the best I've got and learn along the way. Starting from reaching out to different organizations and probing through the idealist. It's important here to look into the idea in the domain of technologies one is working with. This way it's easier to complete application tasks before, and complete the objectives with good quality code during the internship period.

Since this was my first time, I decided to go through the Student Guide for GSoC and follow the prerequisites needed order to participate. After signing up and submitting my Proof of Enrollement, one is free to focus on finding a suitable organization, reading through the idealist and working to complete application tasks given by the mentors.

Debian - The Spark

The time GSoC idea list went live I was learning about Web Extensions and coincidently Debian had 2 projects who's end goal was to create Browser Extensions. So I got excited about them and started with Debian's Create a successor to the Telify plugin using WebExtensions. Because of not being able to find a mentor who could help me guide through legacy Telify code I was sure I will not able to complete application task in time. So I pivoted, and there it was, Wizard/GUI helping students/interns apply and get started.

My mind exploded with the ideas and the possibilities of feature set which can be incorporated into this project. 'Open Source Buddy' came to my mind while naming the application for the task and I began with the UI design using Inkscape which I was going to code eventually. I'll be writing a blog soon focusing entirely on the application task I created with all the technical details as well. One can find the source code with a demo video for the same on Salsa. The project idea was to create a GUI application which can help students or interns get started with their Open Source contributions. The application will guide through the tools of the trade like Git, Github, GnuPG etc and explain the importance of communication via IRC, Mailing List etc. I planned to use PyQt as suggested on the idea description to begin with the application task. More on this later.

After selecting the project and being absolutely sure that I'll work with the best I've got for this project in the internship I began probing more about the organization on how to do things the right way. I came across Daniel Pocock's blog (who is also my mentor for this project) on Want to be selected for Google Summer of Code 2016? mentioned in the description of the project idea I selected, shaped my views in order to understand the project better. Reading more about Debian and how to join the Debian community from a dedicated Debian GSoC page, I did following things

Mailing List - I joined Debian Outreach which was a dedicated list for discussion of Debian's participation in internship-like programs, such as Outreachy, Google Summer of Code, etc.
IRC - In order to join Debian channels on IRC, I configured OFTC on ZNC which I was already using for Freenode (#pydelhi, #dgplug, #pyconindia, #python-gsoc) and Mozilla (#introduction, #development). This way I don't lose any of the messages when I'm not online and can connect with ZNC using any of the clients on Laptop or Mobile.
Wiki - I signed up for Debian Wiki account and was blacklisted because my email address included .xyz domain. Thanks to Steve McIntyre and Paul Wise from the Wiki Admin Team for helping me out. I finally created my account and afterward, I created my own wiki page.

The Proposal Deadline

March 27, 2018 - 21:30 (IST) was the deadline for proposal submission. Proposal showcases what a participant understands the project idea and can elaborate on how they plan to create it. It also showcases more about participant's past work and experiences mostly related to the same technology they'll be using. Student Guide contains few general guidelines which tells about important points that should be included in the proposal. Apart from these, it's always a good idea to talk with mentors what they think should be included in the proposal. I took my time (close to 2 days) in order to research and come up with the best feature set and methodologies which can be used to make an amazing project. After the review process, here's the Final GSoC Proposal which I submitted.

What's Next!

I plan on integrating the Open Source Buddy with pylint, pytest and working more on GUI and PyQT so that if I'm selected for the project, using the tools of trade would be easy and I can focus more on the features. This was my experience till the project submission in brief. I'm planning to continue this GSoC blog series in order to share all that I learn along the way. Next up, a blog explaining how I completed application task - Open Source Buddy.

IMPORTANT UPDATE

I got selected for Google Summer of Code 2018 under Debian and my project is Wizard/GUI helping students/interns apply and get started.

I've also added second blog in the series titles The Application Task and Results. Check it out!

Recovering commit after git reset --hard

2018-03-21T00:00:00+05:30

Problem statement

One not-so-fine day when you are working on your project and do a git reset --hard HEAD~n because, well, you skipped breakfast, your brain is not working properly and you don't want to take the high road of debugging commits. You sadly lost some of your important commits and you forgot to create a backup branch.

Before we move on, if you don't know what git reset do checkout this documentation.

Where do the commit go?

After you do git reset --hard HEAD~n the current branch's HEAD is placed to the requested commit i.e. HEAD~n and all the top level commits which were made afterwards are discarded or become 'dangling object' in the eyes of Git. Now, Git places dangling object inside .git/lost-found/ directory. Phew, it's a relief to know that Git is not deleting anything permanently even though it's not present in any of the branches. All we have to learn is how to probe further and get the commit back.

Option 1 - reflog

Reference logs or reflogs keeps a log of changes happening with project with respect to the tip of all the branches. So whenever you are adding a new commit, checking out another branch etc. reflogs are updated.

That means, reflog must have peeked while we were busy screwing up the project and can help us out in telling us what exactly we did. By doing a simple git reflog you might see something simliar of a structure.

04fa8ba HEAD@{0}: reset: moving to HEAD~1
aab9d00 HEAD@{1}: commit: just add it okay

The log is maintained in reverse chronological order and hence HEAD@{0} becomes the latest activity we did and it is exactly where we messed up i.e. reset: moving to HEAD~1. If you go a little further down you'll find the commit: with the message you gave. This is our dangling commit we were looking all around for. The important thing to notice here is the short hash i.e. aab9d00 in above case. Now simply do a git reset --hard aab9d00 by replacing aab9d00 with your short hash for the commit and you'll find yourself back in time where no one knows you did anything wrong ;)

Option 2 - fsck

fsck checks the objects present inside Git database i.e. it probes whether or not something messy happened inside .git directory of your repository. Since we already know that dangling commits are saved inside .git/lost-found/ we can use fsck to find out more about them. Doing a git fsck --lost-found will result in something similar to the following result.

Checking object directories: 100% (256/256), done.
dangling commit aab9d002015a9bb8d4f66c2e378a7da5f7077e0c
dangling commit 9489726b0d165d4a18c677f703e4dc757617781a

Here, fsck is first checking the database and then because of the flag we gave i.e. --lost-found it goes on and prints the dangling objects. In above case we have 2 dangling commit which might happen something if you have been mischievous for more than one time. No worries, let's look inside individual commits and see why they were created using git show aab9d002015a9bb8d4f66c2e378a7da5f7077e0c. You have to replace 3rd argument or long hash i.e. aab9d002015a9bb8d4f66c2e378a7da5f7077e0c evertime to probe individual dangling commits. It'll show you something similar to the result below.

Author: Shashank Kumar <abc@shanky.xyz>
Date:   Tue Mar 20 23:53:33 2018 +0530

    addind new file

diff --git a/n b/n
new file mode 100644
index 0000000..b14df64
--- /dev/null
+++ b/n
@@ -0,0 +1 @@
+Hi

We get a very descriptive message with git show which contains date, time, commit message and diff in the commit. After you get the commit you were looking for, simply repeat the process but this time with long hash i.e. git reset --hard aab9d002015a9bb8d4f66c2e378a7da5f7077e0c. Phew!

Conclusion

Shit go wrong all the time
Hack all you want for all you need your machine to do
An Open Source software just saved you from spending a lot of money on data recovery. Embrace it!

MozAMU - My first talk for Mozilla and first visit to Aligarh Muslim University - 24th February 2018

2018-02-27T00:00:00+05:30

AMU at PyCon India 2017 - Where MozAMU idea was pitched

During PyCon India 2017, folks from Aligarh Muslim University visited for their first time in PyCon. Rahul Jha, who has been a GSoC 2017 student for Coala came with some of his friends. Sanyam and I were the core organizers and looking into the Open Spaces when we met Rahul and team. Rahul, being an Open Source contributor already needed help building a community in his own college. For this we all went to a separate room for an Open Spaces on How to nurture foss communities in colleges and Sanyam took the charge of sharing his experiences and trying to find out what troubles folks were facing in order to build the community. It went on for like a couple of hours and AMU folks showed interest in hosting Sanyam for a session on Open Source Contribution. After pitching this idea Rahul and team started doing meetups in their college to share about Git, Linux and more which are essentials in order for someone to begin with their contributions.

Planning MozAMU and Trip to Aligarh

Months after when AMU folks were successfully doing meetups on Open Source technologies Sanyam being a Mozilla Representative decided to free one of his weekends (24th February 2018) in order to give a session on How do I start contributing to Open Source? and showcase various ways one can contribute to Mozilla and other Open Source projects. I got roped in for a mini session on building addons using Web Extensions API and contributing to Firefox afterward. Shivam Singhal, who is another of Sanyam's mentee planned to help me out during my session by solving problems that may arise on a participants system while live demo. Since none of us had been to Aligarh before, we took help from Omair Khan an ex-AMU student currently pursuring his bachelor's from Jamia Millia Islamia University, Delhi, and an open source enthusiast.

Sanyam Khurana in pro-speaker mode

This is the first time I've witnessed Sanyam giving a talk on Open Source although he has been doing this for a couple of years now in colleges and other Mozilla events. He began with an interactive session with the audience in order to get a sense of what problems they were facing and which technology is widely used by them. He skipped his own introduction after everyone was finished for a specific reason for the end of the session and began explaining Why you should contribute to FOSS with the help of slides he curated. After a while when most of the participants came to a conclusion the reasons became more clear for everyone. This is where the session got interesting. By this time everyone has understood the importance of FOSS and how it can affect their career also.

My first talk for Mozilla on Web Extension or Browser Extension

I've been very active in Open Source Communities for the past couple of years now and have given several talks and workshops since I started. It's always better to write a blog or give a talk on the technology which one is working on in order to make the concept more clear. I recently started learning how web extension works and contributing to AMO. So, given this opportunity, I started working on slides for the session. From my experience, I wanted to focus more towards the lifecycle of addons as they are installed and run on the browser. I used the first extension tutorial provided by MDN and spread the contents so that to make everyone understand what each of its elements were doing. As the addon began to take shape in the live demo I instantly took the chance of interacting with participants and converging their thoughts on its lifecycle. Sanyam and Shivam helped me along the way to sort out the problems individuals were having and at the end of it all we asked everyone to make something creative out of the API.

Concluding with How do I start contributing to Open Source?

After a while when everyone was comfortable with the concept of FOSS, Sanyam took the last session on How do I start contributing to Open Source?. Finally, he spoke more about himself revealing that he's just like everyone else and a part of the community. He then elaborated on all the basics knowledge one needs and etiquette one should maintain while communicating online with other contributors. Most of the beginners get overwhelmed by the huge codebase and the first step seems hard to them in this case. Sanyam then explained what are the ways one can begin with reading code and collaboration. He then showcased OpenHatch Training Missions which can help beginners kickstart working with version control system. Open Hatch projects which folks can use to find issues to work on. He then showed how one can contribute to Mozilla by using the well know What can I do for Mozilla? website and Bugs Ahoy. The session concluded with one last picture and networking session.

Lunch and Goodbyes

After the enriching and exhausting day of sessions, the core volunteer team headed to grab few bites to eat. There we shared our previous experiences and discussed personal projects. AMU folks have created an amazing community for themselves and thrive with every interaction they make during such sessions. I would like to give a shoutout again to the amazing people of AMU and I hope we would see each other again for future collaborations. From MozAMU I got to be a part of yet another enthusiastic bunch and I thank everyone at AMU for that.

Checkout some more photos from the day. Cheers!

What Pelican quickstart actually do and how it does that?

2018-02-12T00:00:00+05:30

I chose to use Pelican to build my personal blog out of my love for Python. It took me two days to go through the tutorials given by Official Pelican documentation and setup Shanky's Brainchild with the help of the Flex theme created by Alexandre Vicenzi. Pelican contributors have made sure you have a quick and easy beginning in order to get down to business asap and evolve as per your needs. For this very purpose, we use pelican-quickstart.

In this blog, I'll go through the process after running the command pelican-quickstart without any arguments inside a virtual environment to see what goes down in the background. Later in the blog, I'll figure out how everything works. You can also move directly to Demystifying pelican-quickstart.

Prerequisites and Warm-Up

Before we start, make sure to have a virtual environment setup, use either venv or pipenv. Install the protagonist package pelican. Optionally, if one is familiar with Markdown like me and want to create website/blog using it, install Markdown package.

Running `pelican-quickstart`

After setting up the virtual environment and activated it, creating a new folder for our website say justanotherblog, running pelican-quickstart from inside the folder, a few questions will be asked by Pelican. As a result of answering all of the successfully, following directory structure can be seen which is in turn created by pelican-quickstart.

justanotherblog/
                content/
                output/
                develop_server.sh
                fabfile.py
                Makefile
                pelicanconf.py
                publishconf.py

Let's look into the question that were asked and how they affect our blog.

Where do you want to create your new web site? [.]

Here, it is asked about the location of the website. The default value is . or the location from where the pelican-quickstart has been called and is denoted by [.]. If one does not want to change the location can simply enter without inputting anything. You can also specify a location like /home/username/justanotherblog.

Resultant - Location specified here will be the parent location for all the Pelican files.

What will be the title of this web site?

When this question is asked, title of the website should be provided. Failure in doing so or just hitting enter here would immediately prompt You must enter something and the question will be asked again.

Resultant - Title specified here will be store inside pelicanconf.py as SITENAME = 'Just Another Blog'.

Who will be the author of this web site?

When this question is asked, author name should be provided. And just like before, failure in doing so or just hitting enter here would immediately prompt You must enter something and the question will be asked again.

Resultant - Name specified here will be saved inside pelicanconf.py as AUTHOR = 'Shashank Kumar'

What will be the default language of this web site? [en]

Whichever language you would like to use to write the content of your blog should be stated here. Language should be in form of 2 letters code and failure in doing so will prompt You must enter a 2 letters long string with the question asked again. You can look up 2 letter code for languages in this ISO 639.1 guide. Default language is English - en as denoted by [en].

Resultant - The choosen language will be stored inside pelicanconf.py as DEFAULT_LANG = 'en'.

Do you want to specify a URL prefix? e.g., http://example.com (Y/n)

Here, you have to state whether or not you want to use a URL prefix or simply host your blog. The default value is Y (y or Yes) or one can also choose n (N or No). Failure in doing to will prompt You must answer 'yes' or 'no' and the question will be asked again.

Resultant - If chosen Y, a subsequent question will be asked to state the URL. If chosen n, SITEURL = '' will be saved inside pelicanconf.py which can be changed later.

What is your URL prefix? (see above example; no trailing slash)

If the previous question was answered with a Y, this question will be asked. Now is the time to state the URL you are planning to host the blog. Although we cannot enter while providing a URL by simply entering (You must enter something will be prompted while doing os), there's no failure to this step as the URL is not validated.

Resultant - The stated URL will be saved inside pelicanconf.py as SITEURL = 'URL stated'.

Do you want to enable article pagination? (Y/n)

Pagination is the property of a blog to provide part of items or contents in one page and shift the rest to susequest pages with proper numering in order to allow easy access. Allowing pagination in Pelican will help showcase blogs on the homepage spreading across pages. The default value is Y (y or Yes) or one can also choose n (N or No) to disable pagination.

Resultant - If chosen Y, a subsequent question will be asked about the no of articles or blogs per page. If chosen N, this will be saved as DEFAULT_PAGINATION = False inside pelicanconf.py

How many articles per page do you want? [10]

If the previous question was answered with a Y, this question will be asked. This is where the number of articles or blogs per page is declared. The default number is 10. There's no failure to this step as number is not validated.

Resultant - DEFAULT_PAGINATION = 10 will be stored inside pelicanconf.py.

What is your time zone? [Europe/Paris]

Time zones are important in order to properly state the date and time of creation of blogs and also while generating feeds. The default time zone is set to Europe/Paris which can be changed by providing another one. Look into this wikipedia guide for the complete list.

Resultant - TIMEZONE = 'Europe/Paris' will be saved inside pelicanconf.py.

Do you want to generate a Fabfile/Makefile to automate generation and publishing? (Y/n)

Fabfile.py and Makefile are used to manage development server, publishing website to gh-pages or via ssh and similar feature. The default answer to this is Y (y or Yes), after which Pelican will ask few questions to create the proper configuration for Fabfile.py and Makefile. If n (N or No) is entered, generation of Fabfile.py and Makefile will be skipped.

Resultant - If Y is selected, configuration for generating Fabfile.py and Makefile will be asked after the next question.

Do you want an auto-reload & simpleHTTP script to assist with theme and site development? (Y/n)

Auto-reload and simpleHTTP scripts are very helpful while in development as they facilitate local server management and auto-reload whenever the content of the website is changed. This step is specifically to ask whether develop_server.sh file should be created with command line scripts in order to provide auto-reload and simpleHTTP facilities.

Resultant - If Y is selected, develop_server.sh will be created with proper configurations.

The reason why before asking for Fabfile.py and Makefile configurations, we are asked about develop_server.sh is because Makefile can also use develop_server.sh to facilitate local server management.

Now, let's look into options that will come up if Y is chosen for generating Fabfile/Makefile.

Do you want to upload your website using FTP? (y/N)

If files of this website is to be uploaded to the server using FTP connection this option can be useful. The default is n (N or No).

Resultant - n (N or No) will leave placeholders inside Fabfile.py and Makefile to be filled later. If Y (y or Yes) is chosen, 3 subsequest questions will be asked related to the FTP configuration.

What is the hostname of your FTP server? [localhost]
What is your username on that server? [anonymous]
Where do you want to put your web site on that server? [/]

Each of the above questions have default value which can be changed later from inside the Fabfile.py and Makefile.

Do you want to upload your website using SSH? (y/N)

Another option one can use to upload their files is SSH, state whether or not you want to configure SSH here.

Resultant - n (N or No) will leave placeholders inside Fabfile.py and Makefile to be filled later. If Y (y or Yes) is chosen, 4 subsequest questions will be asked related to the SSH configuration.

What is the hostname of your SSH server? [localhost]
What is the port of your SSH server? [22]
What is your username on that server? [root]
Where do you want to put your web site on that server? [/var/www]

Each of the above questions have default value which can be changed later from inside the Fabfile.py and Makefile.

Do you want to upload your website using Dropbox? (y/N)

Another helpful option is using Dropbox to upload the files, this is where you state whether or not you would like to configure it.

Resultant - n (N or No) will leave placeholders inside Fabfile.py and Makefile to be filled later. If Y (y or Yes) is chosen, only 1 subsequest question will be asked related to the Dropbox configuration.

Where is your Dropbox directory? [~/Dropbox/Public/]

Above questions have default value which can be changed later from inside the Fabfile.py and Makefile.

Do you want to upload your website using S3? (y/N)

If you have a Amazon S3 web service configured, state y to use the option to provide your configuration details.

What is the name of your S3 bucket? [my_s3_bucket]

Above questions have default value which can be changed later from inside the Fabfile.py and Makefile.

Do you want to upload your website using Rackspace Cloud Files? (y/N)

Rackspace Cloud Files users can use the Official API to upload files of the website, by enabling this option the API can be configured.

What is your Rackspace Cloud username? [my_rackspace_username]
What is your Rackspace Cloud API key? [my_rackspace_api_key]
What is the name of your Cloud Files container? [my_cloudfiles_container]

Each of the above questions have default value which can be changed later from inside the Fabfile.py and Makefile.

Do you want to upload your website using GitHub Pages? (y/N)

GitHub Pages are also supported by Fabfile.py and Makefile, entering y will about more details for it's configuration.

Is this your personal page (username.github.io)? (y/N)

Above questions have default value which can be changed later from inside the Fabfile.py and Makefile.

Demystifying `pelican-quickstart`

The entire process ends up in the desired project structure as stated above. Now let's look into the other side of the action Pelican contributors have put a lot of efforts in.

Handling Command-line Arguments

pelican-quickstart used argparse to handle command-line arguments which user can provide at the very beginning. By running pelican-quickstart -h it's more clear which arguments one can provide.

PATH - Use -p path/to/folder to provide the desirable path for website
title - Use -t Website-Title to provide the title
author - Use -a Author-Name to provide the name of author
lang - Use -l en with 2 letter language code for default language

Once the program is executed, an ArgumentParser object is created which can handle above optional arguments and store it in a dict object. The values of this dict can be checked further in the program to ask appropriate questions.

The Interrogation Process

pelican-quickstart has a dict named as CONF with default configurations which are modified with every question asked to the user.

CONF = {
    'pelican': 'pelican',
    'pelicanopts': '',
    'basedir': os.curdir,
    'ftp_host': 'localhost',
    'ftp_user': 'anonymous',
    'ftp_target_dir': '/',
    'ssh_host': 'localhost',
    'ssh_port': 22,
    'ssh_user': 'root',
    'ssh_target_dir': '/var/www',
    's3_bucket': 'my_s3_bucket',
    'cloudfiles_username': 'my_rackspace_username',
    'cloudfiles_api_key': 'my_rackspace_api_key',
    'cloudfiles_container': 'my_cloudfiles_container',
    'dropbox_dir': '~/Dropbox/Public/',
    'github_pages_branch': _GITHUB_PAGES_BRANCHES['project'],
    'default_pagination': 10,
    'siteurl': '',
    'lang': _DEFAULT_LANGUAGE,
    'timezone': _DEFAULT_TIMEZONE
}

There are 3 variables used inside CONF.

_GITHUB_PAGES_BRANCHES - It's a dict which contains local and remote branch information.
```
_GITHUB_PAGES_BRANCHES = {
    'personal': 'master',
    'project': 'gh-pages'
}
```
_DEFAULT_LANGUAGE - locale is used to access the user's default language from their local machine. It's set to English by default or in case the local machine doesn't have a default language.
_DEFAULT_TIMEZONE - tzlocal package is used to figure out the local timezone of user's machine. It's set to Europe/Paris by default or in case of failure in fetching local timezone.

Cross Version Compatibility

pelican-quickstart is a great example of how a Python program can be made compatible with both Python 2 and 3. For this purpose future, codecs and six packages are used.

six is compatible with both Python 2 and 3 and helps in figuring out which of the functions should be used if either of the versions is encountered. Once such instance is when we need to figure out whether to use raw_input() or input(). A boolean six.PY3 is used which results True if the version is Python 3 and False otherwise. Hence the appropriate function can be returned as seen below.
```
def _input_compat(prompt):
    if six.PY3:
        r = input(prompt)
    else:
        r = raw_input(prompt)
    return r
```
future is used to bring support of print() using print_function and provide UTF-8 support to print function using unicode_literals. Or as Python lovers say, bringing future to earlier versions of Python.
codecs is also compatible with both Python 2 and 3 and provides support for file management. Mostly codecs.open is used by pelican-quickstart to facilitate the compatibility.
```
with codecs.open(os.path.join(CONF['basedir'], 'pelicanconf.py'), 'w', 'utf-8') as fd:
```

Creating files and folders out of thin air

To finish of, all pelican-quickstart has to do is create files and folders considering all the configurations it has taken from the user. To create folders, os.makedirs is used from os package is used. Creating folders is rather a simple process as compared to how files are generated using configurations provided.

Jinja2 plays a major role in facilitating the smooth transition of configurations to Python, .sh and Makefile. Jinja Templates for Makefile, develop_sever.sh, fabfile.py, pelicanconf.py, and publishconf.py are already stored within pelican-quickstart. Now the task of is to open the template, use CONF dict to find out all the important configuration and replace the value with the placeholders named with similar key as in CONF. For example, pelicanconf.py.jinja2 contains AUTHOR = {{author}} where author is replaced with the value of author in CONF and a new file pelicanconf.py is created after all the replacements.

These are most of the content I understood by reading the source of pelican-quickstart and looking into the repository itself. In case you find any error in my blog feel free to comment down below or reach out to me and help out in making this blog a little better. Thank you for your patience.

Migrating data between different machines with scp

2017-11-20T00:00:00+05:30

Migrating data from one machine to another is easy if both of them are physically accessible and in a same room. Just use a pen drive and it becomes the safest way too. But what if both the machines are further apart? The solution to this problem is what we are going to discuss in this blog.

Let’s recall on of the most basic methods we use to copy file/folder from one location to another. Yes, it’s cp(copy). We use it as cp source destination to copy files from source to destination. In our case we might have source or destination as remote location instead of somewhere in the local machine itself. We’ll use a tool which will look syntactically similar to cp in the beginning know as scp(secure copy).

This way is recommended when you are trying to transfer the data only once from source to destination in a single pass. In order to transfer multiple files/directories and have a better session based control over your connection ftp is recommended.

What is scp?

scp is a tool on Linux which is used to copy files between remote machine or servers. scp uses ssh and utilizes it’s authenticity and security for file transfer which is a win-win for users. So, to use scp you need to setup ssh server on the remote machine.

Transferring files with password

If your remote machine or server has a user and password setup which you use to login then scp will work in the similar way.

scp /tmp/myfile username@0.0.0.0:/tmp/

Here we’re trying to copy myfile from /tmp/ to the machine who’s IP address is 0.0.0.0. You’ll also notice that before the IP address we mention username with which we want to access the remote machine. And finally we add : with the folder to which we want to copy our file. So, /tmp/myfile becomes source and username@0.0.0.0:/tmp/ becomes destination.

When you run the above command you might be asked for a password. Simply enter the password and the copying will begin.

Transferring files with a key

To provide more security a key can be used in place of password using public key cryptography. You need to create a key pair using ssh first on the remote machine and then use it from the machine you are trying to access the remote machine as follows.

scp -i ./mykey.pem /tmp/myfile username@0.0.0.0:/tmp/

You can see the change clearly as we have added -i flag to signify that we’ll be passing a key, followed by mykey.pem which the location of our key. For the first time you’ll be prompted to confirm the connection with a yes. Transfer will begin soon after that without any password.

scp is very easy to use tool for quick transfer without the fuzz of session management. In future blog post I’ll try to simplify the use of tcp as well. You’re free to use whichever suits you most and that my friend is the beauty of FOSS. Embrace it!

Python Game Challenge by PyDelhi, November 2017

2017-11-11T00:00:00+05:30

PyDelhi organized Python Game Challenge on 11th November, Saturday, 2017. Here’s what happened!

Python is multi-talented friend of ours which can assist on all our crazy projects irrespective of the type. PyDelhi came up with the idea of showcasing an underrated potential of making games via competition. Participants were asked to follow only 2 rules for doing so

Game should be developed using Python
It should be developed on the venue during the given time and there begins the competition. We’ve recorded some of the game pitches by participants and gathered few words from them about their experiences below. And after the pitches we’ll announcing winners later in the blog.

Chessmate

Github Repository

Note from the teammates:

It started 1 Hour late, but the 1 Hour wait was worth it. It started by a talk on Open Source Data, exploring different data sources and Public APIs and how they can be used as a potent tool in a country like India with fewer Hardware resources for countering Air pollution which was at its worst in NCR in the ongoing week.

2 Hours into the challenge, we working on figuring out the design and the schema of the codebase to create the game. An hour later our chessboard was fully functional and we were coding on tasks like-

Moves validation

Checkmates

Knights and Pawn special cases

We finished the game 30 minutes before the end time and performed end to end testing and were the first team to finish and present the hack out of the total two who completed it.

Arrow Monster

Github Repository

Hit and Win

Github Repository

Note from the teammates:

The idea to make this game “thor” is to showcase how easy can it be to interact with physical computing hardware devices with Python programming language, we knew most of the participants if not everyone will be making software games so we decided to make “Thor” a miniature version of hammer game you must have seen/played in arcade game centers.

We made it using Force sensitive resistor as sensor a micro-controller and few LEDs, the score is sent to PC via serial port and a daemon handler written in Python parses that using PySerial library! The result was not perfect but we achieved proof of concept and we will surely work on improving it.

The event was really good and happening, we look forward to attend more such events/hackathons by PyDelhi. Initially we get less support/interests from volunteers who stopped by seeing us playing with circuits on a software based hackathon but when we demonstrated everyone was curious to learn more about our game which was our primary goal! The presentation experience was lukewarm and an area to work on, if it could be more interactive where every team is involved (apart from just judges) asking questions, suggesting improvements it’d be more fun. Cheers to PyDelhi for conducting such a successful event. :)

Maria

Github Repository

Note from the teammates:

It was great pleasure to be a part of this event. I entered in any competition out of my college for the first time and it was a great experience. I just a completion post on meetup group and the main purpose i came there was to see how other people make game. I on the other hand had no knowledge how these games are made.When the event started someone said game can be made only using python as well. I also entered the completion without any knowledge of anything and then i started discussing the game with my partner and started building the game at around 2. I had no knowledge of PyGame so we starting doing what we wanted to instead of making a perfect game.

We first made a base (box) using PyGame, just googled it. Then we started loading images of character, keys and bricks into the box, then wrote an algorithm so that character won’t go out of the box or does not go behind the bricks and a few other things in the remaining time.

But its not about what we did, its about what we learned. With no knowledge of any game library like PyGame we made a small game. Now, when i read a little about PyGame it’s completely clear what were we doing wrong. Overall it was a great experience and the organizers were great as well who gave goodies to participants as well.

Up Up Away

Github Repository

And the winners for Python Game Challenge are Chessmate, Arrow Monster and Hit and Win. Congratulations to all the participants who won and thank you all for coming to the PyDelhi meetup. Keep in touch on our meetup, twitter and facebook page for updates on upcoming events.

PyDelhi + Ilugd + LinuxChixIndia Meetup, as it happened on 5th February 2017

2017-02-05T00:00:00+05:30

While I was making my way to SCIS inside JNU all the memories from PyCon 2016 came back to me. SCIS is just opposite to the Convention Center where PyCon took place. That was my first ever conference and I met a lot of awesome people.

Speaking of meeting awesome people, there I was inside SCIS in a room filled with ‘Python Enthusiasts’. That room reminded me of my school but this room was equipped with gadgets to make a difference form a classroom. As usual I saw Akshay (qua non) controlling the audience and the fact that our second speaker is not at the venue yet. So, it began with him welcoming everyone.

TensorFlow by Mukul Malik and Rishabh Shukla

This talk takes a deep dive in the topic i.e. buzz-word of past couple of year ‘Machine Learning’, so to give you a context read Introduction To Machine Learning by Mukul. Rishab began by explaining the basics of how a neural network learn and reduces error by each iteration to subdue a goal. The role of TensorFlow here is to provide powerful modules to do complex computing efficiently like finding a needle in a haystack (figuratively).

As an example, let’s take a data set of English sentences and we have to distinguish each sentence for whether it’s a ‘Fact’ or not. To achieve this, we first perform some preprocessing on our data set to turn them into ML-friendly ‘Word Vectors’, there goes another blog by Mukul. Now we provide an understanding to our algorithm about ‘What is a fact ?’ with help of a database filled with values. Our algorithm begins with raw word vectors in the first iteration and results in a floating value in between ‘0’ (Not a Fact) or ‘1’ (Fact). With every iteration it reduces some ‘error’ in the actual value with the help of ‘bias’. Think of ‘error’ is what we determine at the end of each iteration and ‘bias’ we provide to the next iteration to correct that. Seems easy right ? It’s not. The code base is overwhelmingly complex at first, and like everything you’ll get comfortable with it by practice.

Bigger picture. A whole lot of conversation happens on the web which is open to everyone (like twitter) and most of which is erroneous remarks. Rishab began with this project to discriminate between what among them is a correct fact and what is just a humbug. And hence showing us a little of the mystical power ML holds.

Google Summer Of Code (and open source), An Interactive Session

After a quick snack break and networking Akshay gathered us together again to make the next session interactive. He began with asking everyone whether they know about GSOC, open source and have been a part of it by making contribution. Some people raised their hands and they had to speak about their experience. I began with recalling the names of organisations that have been a part of GSOC and many other names were added by experience people in the audience. Many of them have been contributing to Upstream repositories and not to forget Akshay who has been part of Kivy and also mentoring for GSOC under it since past 6 years. Akshay then explained how we can monitor for projects and apply to GSOC. Amit also shared his experience with GSOC and how he mentored for SymPy where he also improved one of their computational algorithms by making it more efficient. Sanyam opened up about his open source contribution to Mozilla and other communities and what mindset we should have while approaching such organisations.

Domain expanded and moved to platforms other than GSOC like Outreachy and RGSOC. Whole idea of contributing to an open source project is to expand our knowledge and obviously a better CV.

Using terminal on GOD MODE by Akash

Next talk gave us a heads up about some of the time efficient tools. Beginning with the history of TTY which are nothing just the virtual consoles you can access by CTRL + F1 to F6 to the difference shell and terminal. Then he introduced us to TMUX or terminal multiplexer or some would say love at first sight. No matter how good we code sometimes it’s the tools we use that’s really important to increase efficiency and also bring swag to your screen. He briefly showed us how we can handle different TMUX sessions and split a window inside it with set of keys. And while we’re at it, a voice came from behind which I instantly recognised was of Anuvrat’s. Before moving to what he said, a monologue

I saw Anuvrat at the beginning of the day when he was sitting quietly giving no account of his presence to other. He’s one of those guys who’ll teach you something really interesting whenever you meet. So I thought of not disturbing him with a ‘Hi’, as I knew something amazing was happening inside his head which he’ll surely put in words at a better time.

So, he said there’s a tool known as MOSH which is a high latency tool to overcome speed and other issues with SSH. I started working with AWS EC2 a couple of weeks back and if you too have headache of a internet connection you can understand the pain of accessing your server instance with SSH. But in just 20 mins TMUX + MOSHgave me a GOD MODE to access my servers.

Hiring, Pitching and More

In this session people from audience are invited to pitch their products, company as employer and themselves as employee. This session also became interesting as I met an interesting man Achint and we had a brief talk about each other’s tech stacks.

Parting Words and PyDelhi Conference

This is the time where we thank everyone for being a part of the event and share links to connect with each other. Shivani representing Linux Chix India and Shyam, Indian Linux User Group Delhi spoke about respective communities and what content they are committed to provide in this pool of meetups. PyDelhi Conference became a part of conversation and people are invited to be a part of it by ‘Buying Tickets’ and ‘Submitting a Proposal’ for talk/workshop. I’ve also proposed a talk for ‘Telegram bot using Python’ which you can up-vote on the CFP website if you want me to show you how I used it by making ‘ViralSemesterBot’ for my college which is basically a notes/news management system build over a bot. After that I was asked to speak the final words for PyDelhi for which I was shocked as it was my first time. But before that, a monologue:

I never hesitate to speak given a chance. Exhibit A, I won a inter-school drama competition which I wrote in complete RAP and also performed a part in it. Exhibit B, I jumped off the stage with a guitar (literally) while performing a song. But this was different, I admired the work of the people in front of me. So I found out that I become nervous speaking in front of intelligent people. Maybe that’s why I can have a conversation with myself just fine, if you know what I mean. ;)

But I spoke whatever I could and pointed several times at PyDelhi website. It’s good to a have a experience like ‘the first time’, for 1) it’ll help in future and 2) ‘first’ happens only once. :D

PS : Every underlined word/sentence is sitting on a hyperlink. Please like and leave down comments, I would be happy to have a conversation.

PyDelhi Meetup, The Tale Of 21st January

2017-01-24T00:00:00+05:30

Just like a regular-alternate Saturday, 21st was planned to have PyDelhi meetup and this time, our host was IIM Lucknow Campus Noida. I reached at around 12 PM near the main gate with my friends. The schedule as on PyDelhi’s Meetup Page promised a yet another exciting session. Minutes after people started arriving, Akshay, one of PyDelhi’s organiser welcomed everyone. You can think of Akshay as ‘the magnificent one’ among the other volunteers of this organisation who make these events possible. Shortly after that he asked the audience to volunteer for the lightning talk, a quick python related talk/session on which they’re currently working on.

My Lightning Talk On Python Telegram Bot

Before the event began I hurtled towards Akshay and said “I did something last night and I wanna talk about it”, by these words in mind I raised my hand for lighting talk afterwards.

Just before that night I worked on Python Telegram Bot, a package which can be used very easily in production to create scripts for Telegram Bot. I began with the basic elements of this package and made PyDelhi Bot and hosted it on AWS Cloud. I showed how telegram.ext and telegram modules and its methods can be used to read client’s message and reply with appropriate message. This bot can be accessed by searching ‘pydelhibot’ on telegram and is already serving links on PyDelhi volunteer group. Hence, it became my first talk on PyDelhi after attending meetup for nearly 6 months.

Amit Kumar With His GIL Swag

After I finished with my beginner talk it was time for Amit Kumar to take the floor and share his knowledge on core Python. So he began by first explaining how variables and their values are handled by Python interpreter with the concept of reference count. Moving forward he then showed us the changes to execution time with or without multi-threading and the results were astonishing in which multi-threading lost. Amit explained how Global Interpreter Lock is responsible for such results and it’s bringing down the performance of threads. He then talked about the famous GIL patch in which Greg Stein removed GIL altogether but it decreased performance of Python by 30x. But GIL holds its place until there someone from Python software foundation comes with a better alternative without compromising performance.

VIM’s Power Show By Garvit Khatri

Garvit volunteered for another lightning talk and proposed VIM for this. He began by firing his editor and using commands to quickly navigate between words and lines. By increasing pace, he then showed us how we can mimic an entire set of operation as many times as we want. After then he showed how we can split the terminal window to open multiple files and left us with WOW. VIM is powerful when used at it’s best and can leave any high end editor like sublime or atom behind by just considering the use of shortcuts.

Snacks And Venue Sighting For PyDelhi Conference

After Amit’s parody of GIL and Garvit’s showcase of VIM’s abilities came the time for snacks and networking. But for the volunteer it was more important than that. PyDelhi Conference is scheduled on March 18 and IIM itself is the venue for the event so we looked at the proposed halls and buildings to plan further. On the other hand website designs was also discussed.

A Brief On The Activities Of IIM’s Incubation

Rajiv Ornsheeba, the Head Of Incubator gave a quick talk on the works of IIM Lucknow Noida Campus. He described the complete procedure about how to apply and what kind of startups they are looking for. He also stated the importance of making revenue around the products we make and how his team can help startups achieve that right from the investments and throughout the journey with the help of professionals.

Python + Other Languages, An Interactive Session

The last and interactive session was initiated by Akshay asking audience about their experience with handling python with other programming languages. Peeyush began sharing one instance from his experience where he had to manage some dockers, the technicalities of which were too in-depth for a beginner like me to remember. Then began a series of conversations among other sharing the same stack about how they handled their situation with other languages. I also spoke a less technical version of these exchanges. My use case was not as native as most of people present used python with some other packages to interconnect it with other languages. Alas Akshay shared a wiki which has a list of many tools to make this possible which can be found here.

Parting Words and PyDelhi Conference/CFP

As the event progressed towards the final segment, Akash and Peeyush took the stage to talk about how we can stay connected to PyDelhi and what PyDelhi Conference is all about. Amit and Shweta joined in to share their experience about previous Pydelhi Conference.

The Conclusion

Finally the meetup came to a close and people started networking to find the solutions to their problems and also to know more about the other. Me with my friends started leaving the venue with Amit and Garvit and gained some pointers from them. While the discussion moved from a good documentation to how to write good code on which Amit said “code is an art. You know it when it’s beautiful.” and suggested Clean Code as a reference to learn syntactically beautiful code.

Just like every other PyDelhi Meetup, this also taught me a lot and pushed me to work hard and learn more. With all these exciting people and many new ones, the day ends with a lot of stories and a promise to make more in the next Alternate-Saturday :D

Thanks PyDelhi :)

PS : please like and leave down comments, I would be happy to have a conversation.