Homebrew on MAC OS (Yosemite) Update


After installed homebrew, when you run any “brew  command”, If you keep getting this error:

Homebrew requires Leopard or higher. For Tiger support, see:
https://github.com/mistydemeo/tigerbrew 

Do the following step to rectify this error.

Edit the brew.rb file to get this : (Which may be at /usr/local/Library)

Find following lines

if MACOS and MACOS_VERSION < 10.5
  abort <<-EOABORT.undent
    Homebrew requires Leopard or higher. For Tiger support, see:
    http://github.com/sceaga/homebrew/tree/tiger
  EOABORT
end    

Do following changes

if MACOS and MACOS_VERSION < 10.5 and MACOS_VERSION != 10.1
  abort <<-EOABORT.undent
    Homebrew requires Leopard or higher. For Tiger support, see:
    http://github.com/sceaga/homebrew/tree/tiger
  EOABORT
end

And yeah you done. Enjoy 🙂

Advertisements

A summer full of code


Four months of constant coding and excitement comes to an end – I still can’t believe I am saying this. While I am really really happy with how these times went – how fast, how satisfying, how perfectly awesome it went. It is just still hard to believe that it has ended – time flies, literally!

Here goes my wrap-up blogpost for all these months of tireless programming. Here’s to a summer full of code! 🙂

Background

As I have mentioned in my last few blog posts on several updates, I have been working on the Language Coverage Matrix Dashboard project for the Language Engineering Team of Wikimedia Foundation as my Google Summer of Code project. This web-based application automates all the information that are available on the Language related topics that Wikipedia and its Sister project covers – tools they support, languages they have support for, statistics that are available for public use etc. The target users are obviously the researchers, linguists, i18 developers, and even MediaWiki developers concerned about the Language technology, willing to implement somewhere else, you know, for good!

That said, I am going to post here a detailed description of the final product that we have achieved so far.

Demo Instance: http://tools.wmflabs.org/lcm-dashboard/lcmd/

The User Interface

We have actually done a lot of thinking around the user interface throughout the period of GSoC. The final one turned out be quite satisfying. The whole page is now divided into two major parts – a) where all the queries that are available would be displayed. b) the results to show. So, now it has become same for the Language based queries, as well as the tools based ones. Filter is there for the tools based queries.

The diagram of the UI is uploaded on commons. Check it out!

Relevant Code: On GitHub!

LCMD – Landing Page

Basic Functionalities

Now that you’ve seen the UI that we have aimed to achieve. Let’s go deeper into the functionalities.

  • Search

    The whole searching concept has been divided into two parts, two ways, to be specific.

    • Language Based Search: Like you can see from the design and the interface that has been implemented, a search bar for the Language search is there. Essentially you get to search for all the Languages that are on the database of ours, i.e. the ones that are supported by Wikimedia Projects. jQuery.ime – a development work by the Language Engineering developers has been implemented on the search. Language search have features like : Suggestions, Auto-Completion etc, to provide users with more efficient search. Output of the search for a particular language would obviously give all the relevant details that we have for that particular language.

Language Search with autocomplete facility

Language Search with autocomplete facility

Language Search Result

  • Tools Based Search: This is important. This basically a feature to play around all the language data we have. I have got a filter for that – a JS application that filters out all the language data with respect to tools based queries. So, essentially this outputs the languages that support particular tools. Tools based queries work around three basic queries –
    • Input Method
    • Webfonts
    • Internationalization Library
  • Filter: 

    As mentioned above the tools based query part does have this feature where you can filter out all the language data with respect to the tools based query. A JavaScript code runs behind to have this running. Outputs the language names that support the particular tools that may be selected on the radio button

  • API Console

    This is probably my favourite feature from LCMD.  If a third party user wants to fetch these language related data then they can easily get data by calling these APIs. For better understanding of API I have developed API console.
    This is similar to MediaWiki API sandbox. In which you just have to select from dropdown and then press on request button and then “BINGO”. Yes you will find

Language API Console

That is almost what it is. Now a quick overview on how I have developed stuff over time, things I have just described above, and the processes behind. This would also include a few stuff that we changed afterwards. Some of the updates you might have followed on my previous blogposts, this one would work as a summary of those.

June – Community Bonding Period:

  • In the community bonding period I first thought/planned about new technologies which I would be using in my project.
  • Started with the database – created the database schema.
  • All the data was in a spreadsheet –  created one python script so that it could transfer all the data from spreadsheet to database automatically.
  • The week after, I started working on new language entry system, database connection and completed it.
  • Implemented language search system with suggestion for the language names.
  • Implemented the feature to get the language details.

July – Coding out the Functionalities, start!

  • Created and set up primary thing on Wikimedia Labs.
  • Done minor changes in Language Search System.
  • Created on the spot editing facility for any language detail under admin privileges
  • Created Filter Facility
  • Database schema changed
  • jquery based new alternative REST architecture created
  • Language to Font mapping
  • Language to Input method mapping
  • Redefining search implementation

August – Coding, coding, coding!

  • Created login system for admin + session management
  • Designed new UI on langfilter.php page
  • Developed PI visualization chart
  • Developed API for language detail
  • Developed example for API usage
  • Created preview system for new language entry system as well as direct editing feature

September – the last touch.

  • Developed API console for 3rd party user to use these data for their website.
  • Redesigned entire NEW UI as per proposed scheme
  • Small correction in functionality
  • Solved a few bugs

Documentations:

All the things that I have documented so far in these four months, here goes!

A note to thank you all, who were there

I loved living this four months of my life. But, Google Summer of Code is not why I love Wikimedia Foundation. Rather, it is just another event that happened between the Foundation and myself. I have been an active volunteer to Wikimedia projects for a long time now. And, yes, I have been thankful for each and every day I have spent with MediaWiki, Wikipedia and the people around all those projects. GSoC has been a different kind of excitement – recognition feels good. Honestly, it does. But what feels even better than that is to get a merged status on some hundred lines of code that I have written. GSoC has given me many merges – I am thankful for each of them. Runa and Alolita have been amazing mentors to me. For all the things I have done good, for all the pushes I needed to do them that way – they have been there always. Special thanks to Quim, Sumana and Sucheta to help me throughout. I am sure, I am motivated enough to live for another four decades just to code. JUST for the sake of coding. Yes. GSoC definitely played a great part on achieving that motivation.


Here’s to Google Summer of Code!  🙂 🙂

How to implement system command using python


In this post I will show you that how you can exactly implemented system command using python.Here we use for example ls -l command. When I use this command in terminal it gives me following output

Harshs-MacBook-Pro:scripts harshkothari$ ls -l
total 32
-rw-r--r--  1 harshkothari  staff    13 Jul 23 02:33 demo.ini
-rw-r--r--@ 1 harshkothari  staff  1864 Jul 23 04:30 filesread.py
-rw-r--r--  1 harshkothari  staff  4121 Jul 23 04:30 langtofontmap.json

Now this command we can implement by following methods using python 🙂

  • os.system("command with args") passes the command and arguments to your system’s shell. This is nice because you can actually run multiple commands at once in this manner and set up pipes and input/output redirection.
    os.system("command < input_file | anothercommand > output_file")
    However, while this is convenient, you have to manually handle the escaping of shell characters such as spaces, etc. On the other hand, this also lets you run commands which are simply shell commands and not actually external programs. http://docs.python.org/lib/os-process.html

    >>> import os
    >>> os.system('ls -l')
    total 32
    -rw-r--r--  1 harshkothari  staff    13 Jul 23 02:33 demo.ini
    -rw-r--r--@ 1 harshkothari  staff  1864 Jul 23 04:30 filesread.py
    -rw-r--r--  1 harshkothari  staff  4121 Jul 23 04:30 langtofontmap.json
    0
  • stream = os.popen("command with args") will do the same thing as os.systemexcept that it gives you a file-like object that you can use to access standard input/output for that process. There are 3 other variants of popen that all handle the i/o slightly differently. If you pass everything as a string, then your command is passed to the shell; if you pass them as a list then you don’t need to worry about escaping anything. http://docs.python.org/lib/os-newstreams.html
    >>> import os
    >>> print os.popen('ls -l').read()
    total 32
    -rw-r--r--  1 harshkothari  staff    13 Jul 23 02:33 demo.ini
    -rw-r--r--@ 1 harshkothari  staff  1864 Jul 23 04:30 filesread.py
    -rw-r--r--  1 harshkothari  staff  4121 Jul 23 04:30 langtofontmap.json
  • The Popen class of the subprocess module. This is intended as a replacement for os.popenbut has the downside of being slightly more complicated by virtue of being so comprehensive. For example, you’d say
    print Popen("ls -l", stdout=PIPE, shell=True).stdout.read()
    instead of
    print os.popen("ls -l").read()
    but it is nice to have all of the options there in one unified class instead of 4 different popen functions. http://docs.python.org/lib/node528.html

    >>> from subprocess import Popen, PIPE
    >>> print Popen("ls -l", stdout=PIPE, shell=True).stdout.read()
    total 32
    -rw-r--r--  1 harshkothari  staff    13 Jul 23 02:33 demo.ini
    -rw-r--r--@ 1 harshkothari  staff  1864 Jul 23 04:30 filesread.py
    -rw-r--r--  1 harshkothari  staff  4121 Jul 23 04:30 langtofontmap.json
    
  • The call function from the subprocess module. This is basically just like the Popen class and takes all of the same arguments, but it simply wait until the command completes and gives you the return code. For example:
    call(["ls", "-l"], shell=True) http://docs.python.org/lib/node529.html

    >>> from subprocess import call
    >>> call(["ls", "-l"], shell=True)
    demo.ini                filesread.py            langtofontmap.json
    0
  • Using command module http://docs.python.org/2/library/commands.html
    >>> import commands
    >>> commands.getstatusoutput('ls -l')
    (0, 'total 32\n-rw-r--r--  1 harshkothari  staff    13 Jul 23 02:33 demo.ini\n-rw-r--r--@ 1 harshkothari  staff  1864 Jul 23 04:30 filesread.py\n-rw-r--r--  1 harshkothari  staff  4121 Jul 23 04:30 langtofontmap.json')
    >>> commands.getoutput('ls -l')
    'total 32\n-rw-r--r--  1 harshkothari  staff    13 Jul 23 02:33 demo.ini\n-rw-r--r--@ 1 harshkothari  staff  1864 Jul 23 04:30 filesread.py\n-rw-r--r--  1 harshkothari  staff  4121 Jul 23 04:30 langtofontmap.json'
    
  • The os module also has all of the fork/exec/spawn functions that you’d have in a C program

Hope this will help you 🙂

Popular Programming Languages


All popular programming languages, for each one the description and why to choose it. New emerging programming languages are also included in the list. 

Complete list

Description

Why use it?

C#
(C Sharp)
Concurrent to java, runs on .NET or compatible platforms (Portable NET, Mono). 
More
 – Code
Easier than C++. May share resources with other languages under a common runtime.
C C offers great freedom, and lot of debugging challenge thanks to pointers and memory management. 
More
 – Code
Suffering slow programming to make fast programs. For system programming.
C++ C++ is C plus objects, an extended library, templates. 
More
 – Code
System programming as C but allow larger project, or applications.
D language C++ like language, more dynamic. Compatible with C.
D Language – Code
For teaching or scripting.
Pascal Old language (1970), improved with objects, imposes a strictly structured programming. 
More
 – Code
Teaching, or client/server apps with Delphi and Kylix.
Basic
ASP
This very old language (1964) was improved by Microsoft, with a complete programming environment. Other portages exist. 
More
 – Code
Standard language for scripting Microsoft’s applications (Word etc…), and for dynamic web pages (Asp) on Windows servers.
PHP Designed to be embedded inside HTML to build dynamic Web pages or update them from databases.
More
 – Code
Producing HTML pages from data.
The version 5 targets Web services.
Java Was designed to be portable and to replace C++.
More – Code
Cross-platform applications. For web services and mobile phone apps under Android.
JavaScript,
ECMAScript
JavaScript has been invented to build dynamic client-side html pages, ECMAScript is the standardized version. 
More
 – Code
For interactivity in web pages and applications.
Used with HTML 5 for Web or local apps on Metro or Node.js or Qt.
Scriptol A simple, object-oriented, universal language with an intuitive and powerful syntax. You can build executables, or embed code into html pages.
XML may be used as data structure. 
More
 – Code
Easy and universal for scripting, prototyping, making binary applications, dynamic web pages and XML processing.
For web services by using PHP 5 as back-end.
Python A modern interpreted language with powerful built-in features and a unique indentation feature to shorten coding.
The Jython version compiles in Java bytecode. 
More
 – Code
Programming at light speed. Powerful and easy to learn.
Extending Zope for web services.
Java scripting with Jython.
Only for open source applications (not compiled).
Boo This is a new version of Python with some new features. It runs on .Net and Mono and thus, no compatibility problem.
Boo – Code
Similar to Python.
ASP Scripting language, server-side, for dynamic web pages by Microsoft, same syntax as Basic. 
ASP
 – Code
Producing HTML pages from data, but under Windows servers only.
Assembler This is near the machine language and the fastest. You should never use it, as older programmers did. Making graphic subroutines, drivers or industrial processing.
Eiffel, Sather Object-oriented, with “programming per contract” and other secure features. Sather is an open source implementation.
More – Code
Programming secured applications. Used by hospitals.
Perl A scripting interpreted language. Readabillity and ease of use are not the goal. 
Perl 
– Code
Mainly used by networks administrators and for small CGI scripts.
Rebol Interpreted language for network scripting. The language itself may be augmented. 
Rebol
 – Code
Processing information on distributed computer systems, with small programs.
Ruby Designed with simplicity in mind. It is interpreted, and has a proprietary but extensible library. 
More
 – Code
Writing scripts more easily. Using Ruby on Rails for Web applications.
Tcl A scripting language, easy to learn and available on any platform.
More – Code
Scripting of portable programs with GUI, and web programming by CGI.
NetRexx By IBM, has a simplified syntax. 
More
 – Code
Extends Java with scripts.
Lua Add-on or standalone language with extensible semantic.
Lua – Code
Extending the C language.
Cobol Business language still used on big computers.
Cobol – Code
Maintaining old programs on mainframes.
Fortran One of the first languages, always used for mathematical tasks.
Fortran – Code
Has huge library for scientific calculations.
Lisp Lisp is a very old language designed for artificial intelligence, processes lists only.
Lisp – Code
Artificial intelligence and scripting.
Scheme Scheme is a modernized version of Lisp.
Scheme – Code
Artificial intelligence and scripting.
Prolog For logic programming, based on Horn’s clauses.
Prolog – Code
Heavy artificial intelligence processing.
Haskell Functional programming. Slow and memory consuming. 
Haskell
 – Code
To try programming in another way
SQL Language of data management. 
MySQL
For databases queries.
Forth Another oldy. Invented by an astronomer, is stack based
Forth – Code
For instrumental commands and legacy libraries re-using.
Smalltalk One of the first object oriented language, programs can’t run outside the IDE.
Smalltalk – Code
Absolutely object-oriented processing.
Modula,
Oberon
Successors to Pascal.
Oberon – Code
For nostalgics of the Algol and Pascal time.
Caml, Ocalm Functional languages, Ocalm is object-oriented.
Caml – Code
Used by universities. May help to build a compiler.
Scala Procedural, functional and object-oriented programming language.
Scala – Code
Provides a more compact syntax than Java on the virtual machine
XML Not really a programming language, but may be used for similar tasks.
XML
XML serves to describe precisely data and may include actions on data.
XSL allows to transform documents.