Takers, Givers and Matchers in Open Source

Recently, a friend sent me a link to the TED talk appearing below:

I found the talk not only interesting, but also it made me think about the Open Source world, trying to apply the same concepts and thinking. I rapidly realised that the Open Source world also has its own set of Takers, Givers and Matchers.

So, let’s talk a little bit about Open Source Givers. The givers will be those who either initiate in open source project, constantly contribute to open source projects, preach and promote the usage of open source as a way of life and most importantly – they do so not because of a commercial or financial agenda – they do so because that’s what they believe in. These include people like John “Maddog” Hall, Linux Torvalds, Richard Stallman, Brian Kernighan, Dennis Ritchie and many others. These people operate under a premise that their work is vitally important, not the world, to mankind and the well being of others.

So, who are our Open Source takers? sorry to say, the number of Open Source takers is far greater than that of the givers. The takers are your “Script kiddies” or “Closed integrators”. Those people who use and abuse Open Source without acknowledging its existence.  In Israel, as an example, when Open Source was still in its infancy stage – people were roaming about claiming that they created a specific project or other. For example, I recall that in 2006, a company in Israel claimed it was the creator of Asterisk – and that their AMP based PBX system is their own creation. How Rude!

Who are your Open Source matchers? matchers are people who jump from being a giver and a taker according to their requirements. These people utilize open source projects, contribute code from time to time, promote the project – nominally due to a business reasoning – and these constitute a slightly bigger portion than the givers. While Open Source innovation relies on Givers, it’s progress into the business world and adaptation to the enterprise relies mostly on Matchers. Takers do not promote the Open Source industry, in some extreme cases, the actually harm the industry.

So, are you a giver, matcher or a taker?

Python should be the first language you learn!

For the better part of the past 15 years, I’ve been a PHP developer. Really, I’ve developed everything in PHP, ranging from server side services, web services, backends – you name it, I’ve probably done it with PHP. Don’t get me wrong, I love PHP and it will always remain my language of choice for doing things really fast.

However, for the past year I’ve been increasingly developing with Python. I’ve always dabbled with Python, but never really had the chance to truly get down and dirty with it. Due to a couple of projects during the past year, specifically ones that involve Google AppEngine, I’ve had to sharpen my Python skills and get to a point where I can develop with the same agility that I have with PHP. Honestly, it wasn’t simple – sometimes I truly wanted to strangle someone with various errors a framework can spit at you. However, once you get around to reading the various cryptic messages Python may spit at you, getting around it and working with it is truly a delight.

So, why do I think Python should be the first language one learns? so here are my thoughts:

I started my coding days with BASIC, to be more accurate GW-BASIC (yes, I am that old). From that I moved to Pascal (Turbo Pascal to be more accurate), then C, then C++, C++ Builder, Visual C++ (yes, I did MFC at some point in my life as well). I then decided that my life is in the open source world – and thus, the track then went to PERL, JAVA and of course PHP. Honestly, somewhere around 2005, the mixture of C, JAVA and PHP truly gave me all the power I needed to do my job – so, I didn’t really find the time to learn a new language.

Then, about a year ago, I decided it’s high time to learn something new – specifically, I became increasingly interested in the Google AppEngine platform. Yes, I’ve been using Google Compute and other cloud platfroms for a few years now, I’ve used most of Amazon’s services, ranging from EC2 up to RedShift and their hosted Hadoop clusters. But when Google AppEngine came out, it only had Python, Java and GO to work with. Java is the least favorite language in my tool box – honestly, I hate it. I’ve never coded in GO, and didn’t really feel like starting out with it. And Python, well, I dabbled with it – but can’t say I’ve done something too serious with it. In 2014, Google added PHP support to Google AppEngine. Damn, that sounds cool – let’s play around with that. So, I built a few applications atop of AppEngine and the PHP SDK. I rapidly realized that while the PHP SDK gives you some power, Python is the more natural choice for AppEngine. So, I more or less sat my ass down for 3 days and decided to teach myself proper Python.

Took me about 3-4 days to get around the quirks of AppEngine and how to get it up and running using PyCharm (if you use Python, by far the best IDE I’ve seen). Then building up my first application, then migrating an existing application (a fairly big one), from PHP to Python on AppEngine. I then rapidly moved along to using easy_install, pip and the other Python tools that make life so easy for developers – honestly, right now, I can’t figure out why use anything else other than Python for shell environment tools. But, regardless of that, I honestly think Python is the first language you should teach students, not C/C++, not JAVA, not Ruby and surely not PHP (and I’m a huge PHP advocate).

Why do I say this? here are my main reasons:

  1. Python is objected oriented from the ground up, which means, that teaching object oriented programming using Python is easy and straight forward for new comers.
  2. Python is strong typed, which means that syntactical issues are dealt harshly – promoting proper usage of syntax, indentation, capitalization, variable handling – all the nice things that make good code – readable code.
  3. Python’s physical typing construct, where blocks of code must be tabulated in specific manner in order to make the code work in specific manner – is GENIUS. I’m very much a “Source Code Nazi” (Imagine that coming from a Jew, right?). For me, indentation, proper loop blocks, proper case blocks, making sure things are wrapped really tight without too many white spaces – this is what makes code look nice.
  4. Python is interpreted, not compiled – but yet, it is strong enough to hold the most complex multi-threaded of tasks.

In other words, if you take the above and teach to a new developer, someone who writes code for the first time in his life – your result will be a developer, that may not dish the best code at first (after all, a beginner), but it will be readable, manageable and maintainable. Python automatically promotes these by its structure, by its rigidness and by its agility at the same time.

As part of my academic studies, I’ve studied education and how to teach computer science to high school students. I’ve learned that you should start with Pascal or C, then move to Object Oriented, then move to more advanced stuff. I have one thing to say: BULLSHIT! Honestly, the first thing you need to teach is Python, after Python, the rest are just syntax. Nothing more, nothing less – pure, simple, straight forward syntax.

Would love to hear your opinion on this one…

Source code and individuality

Developers! We are the modern day artists, the masters of the keyboard and the sculptors of algorithms and ideas. We turn obscure thought and imagination into real life creations, capable of doing things previously not done (well, at least not in the same form). As such, we are individuals and unique – each one of us in our own way. Whether we develop a mobile app or a web application, our unique style, way of thought, organization and coding style will be reflected into our creation – we can’t help it, this is who we are.

About 2 years ago I’ve done a project for a start-up company in Israel, where I developed a full blown switching environment for them. I worked on that project for around 9 months and how shall I put it, my name was all over the place. Normally, when I take a piece of code from the OpenSource/PublicDomain, I will document where it came from within the code – then I will add a simple remark next to my modifications.

So, the other day I met one of the new developers working on the project – who didn’t know I was the original developer. And he told me about some issue that he was having with his project – so, in a very natural way, I pointed out to him that the original code wasn’t meant to work like that, specifically, he should into a specific function to resolve the issue and add some additional code to make it work as he wanted. The guy was shocked – “What the hell? are you psychic or something? how can you know that?” – I replied – “Well, I wrote the damn code, I should know”, which followed by me showing him the original source code on my computer. The guy said: “Yes, that is the source code, but all the remarks of the original source code are gone”. Seems that following my departure from the project, someone went into great length in order to remove the various comments I’ve put into the code, to make its origins as unclear as possible.

So, on one hand, I truly understood it – after all, the guy running the show doesn’t want the new people to call up the previous developers and exposing new stuff to them – even if by mistake. On the other hand – Dude, are you really that lame? are you really the afraid that your team will know who wrote the original code?. Source code is a living organism, it is an unique as the person who wrote it and will evolve and change as more people write more code. The Asterisk project still contains remarks that Mark Spencer put back in 2002 – and they are no longer relevant to the existing code, but only to an obscure part of the original code – but it’s still there.

So, to sum up, I never remove remarks that other people wrote from my code – it’s rude, it’s bad practice and worst of all – it’s ugly and disrespectful. Developer will join and leave a project, show your minimal level of respect by respecting their code and their remarks, leave them where they are – removing them is just like performing an act of murder.

Can you say – antitrust?

Version control! one of the most controversial subjects in the software industry. Whether you’re a Subversion fanatic, a Git hard core or a mercurial elitist – everybody has something to say about version control. While in the past we had put our trust in local CVS and SVN repositories, today, most of use utilize cloud based services such as Github, BitBucket or Gitlab.

After spending much time this week setting up our new gitlab repositories – mainly for finished projects that are no longer in active development, and can be removed from our quota at Github, I cam to realize that all these companies are somewhat at a position to be considered as “anti-trusted”. Imagine a hypothetical situation where github starts examining the code we submit to it, not only the public one, but also the private one. Imagine what kind of intellectual property assets they have access to.

In 2001, Tim Robbins portrayed a software giant CEO that is so driven by ambition and greed, that he is actually willing to have developers killed for their code. Where in 2001 developers were very much working in closed quarters and sharing their work via privatized means, today, almost all of us use the clouds in some form. Can they be trusted? What happens if one of them gets bought out by a software giant?

Let us imagine the follow scenario:

The GitGiantCloud (GGC) service has been recently acquired by MegaGreedySoftwareCorp (MGSC). MGSC announces that it will continue to run GGC as always, however, in the background they start analyzing the code within the privatized repositories – completely violating their EULA. Would anyone know about it? the answer is NO. Is it considered a breach? well, they can always excuse it as: “we identified a potential breach, we had to take these measures to investigate it”. In other words, even if they are reading your code – you’ll never know if it’s true or not.

Mobile VoIP OTT is Dead! – Long Live Mobile VoIP OTT!

What do the following have in common: Skype, Viber, Whatsapp, Line2, Tango and Kakao? Yes, there are all OTT apps for your mobile phone that enable you to communicate with your peers. Skype, Viber, Line2, Tango and Kakao actually enable you to call one another. Each one dominates a section of the world, where Kakao and Line2 are dominant in the far east, Viber dominates Japan and Eastern Europe and Skype kind’a says: “Look at me bit**es, I’m all of you combined”.

What do the following have in common: VoipDiscount, Nymgo, WiCall, VoIPstunt, Vox Mobile, Cloud Roam, Skuku? All of these are VoIP Mobile OTT apps, similar to the above and yet – no one truly heard about these or is using them. Each one of the above is more or less a replica of the previous one, maybe with one or more added features – but all in general are the same pitch and bit**, make cheap calls over VoIP via our service.

So, what does it all mean? it means one simple thing, no one truly cracked the formula to make money on the Mobile VoIP OTT business – everybody is still looking for the killer business model/VoIP OTT Application. What is the right way? providing low cost calls? providing business oriented services? providing simple roaming solutions? maybe bundling roaming data plans and SIM cards? or maybe, all of these are sooooooo passe that the world just says: “Stop fu**ing about and create some truly new, change how think and how we work completely. Paying 1 or 2 dollars more per month, I’m not gonna change my service for that – it’s pointless.”

So, what are the true killer apps that will truly say: “this is a game changer, from this point onward, VoIP OTT will no longer be the same!” – Here is a list that I believe will make the difference:

1. Make calls completely social – Phone numbers are so 18th century, they are pointless

2. Make your phone aware – Presence and availability is key

3. Drop the stupid things – call recording, visual voicemail, funny sounds, funky tones – stop the bullshit, give me proper services than stupid features

4. Make your service reliable – stop behaving like a website operator and thing like Ebay, every minute your service is down or affected by bad service you are loosing money

5. Make work, then make pretty – application design is important, product design is important, but not more than the product itself

6. Invest in support and monitoring – relying on your suppliers to do it for you is stupid and childish

7. Only blame yourself! – when something fu**s up, it means that you did your job wrong and you cut corners. Don’t start blaming your colleagues or your contractors, they are only doing what you asked them to do

And most importantly, remember the following statement: “I’ve seen the furthest, because I sat on the shoulders of giants.” – don’t tell the world how you’re going to obliterate Whatsapp and Skype, look at them, strive to be them, and then do it better.

I wish all of you good luck.