cjus

#!/bin/bash
function jsonval {
    temp=`echo $json | sed 's/\\\\\//\//g' | sed 's/[{}]//g' | awk -v k="text" '{n=split($0,a,","); for (i=1; i<=n; i++) print a[i]}' | sed 's/\"\:\"/\|/g' | sed 's/[\,]/ /g' | sed 's/\"//g' | grep -w $prop`
    echo ${temp##*|}
}

json=`curl -s -X GET http://twitter.com/users/show/$1.json`
prop='profile_image_url'
picurl=`jsonval`

mssola

package main

import (
    "fmt"
    "math/rand"
)

const N_WORKERS = 10

func producer(c chan int) {

mssola

#!/usr/bin/perl

use strict;


##
# List & hash references.

package Class
{

mssola

#!/usr/bin/perl

use strict;

# Decorator. Same idea as the Python decorators. In this case it takes a
# function as the only argument and returns a closure that returns the result
# of the originally passed function plus two.
sub plus_two
{
    my ($f_ref) = @_;

mssola

# This file shows a somewhat rare feature of Ruby with the .. operator.
# It's a a perlism called "flip-flop". This feature will make it into Ruby 2.0
# but its future is uncertain (probably removed in a future Ruby 3.0 ?).
#
# More on flip-flops here: https://bugs.ruby-lang.org/issues/5400


# Prints all the lines between begin..end in the DATA section.
DATA.each_line do |line|

mssola

##
# This file describes some topics regarding the Ruby Object Model.
#

require 'pp'

##
# First of all, let's take a look at the very basics.

module Modul

mssola

##
# This files shows some possible implementations of the Singleton pattern
# in Ruby. I'm not a huge fan of the Singleton pattern, but it's nice
# in some cases. In this file I'm going to implement a simple logger.
#


##
# The first implementation that can come to our minds is to create a class
# that holds an instance as a class variable that can be accessed through

mssola

#
# This is a simple script that creates a TCP server and then transfers
# the info via streaming. It's not too fancy, I'm just testing the HTTP's
# Transfer-Encoding: chunked;
#


require 'socket'

# This is the message to be sent.

mssola

##
# This file describes a simple way to implement the idea of pure virtual
# methods (abstract methods in Java, C#,...) in Ruby. Personally, I haven't
# used this pattern while programming in Ruby, but I thought it could be fun.
#


##
# This class provides a fancy way to show an error when a virtual method
# is being used but the subclass hasn't implemented it.

mssola

class Persistent(type):
    def __new__(self, name, bases, dct):
        self.tables = dict()
        return super(Persistent, self).__new__(self, name, bases, dct)

    def __init__(self, name, bases, dct):
        table = name.lower() + 's'
        self.tables[self] = table
        super(Persistent, self).__init__(name, bases, dct)