Spark U @sparku-blog - Tumblr Blog

Learn Python the Hard Way

Exercise 10: What was that?

takeaways:

learned that the triple quotes and \n are escape sequences

more escape sequences: http://www.java2s.com/Code/Python/String/EscapeCodesbtnar.htm

Useful: /t will add a tab, \n will create a new line, \\ will create a \ and """ will allow you to include as many lines as you want.

Learn Python the Hard Way

Exercise 9: Printing, Printing, Printing

Takeaways:

\n will put the following on the next line

if you use three quotes after print """" you can type as much as you want and close it with three quotes """ no " or ' will appear around the string.

Learn Python the Hard Way

exercise 8: Printing, Printing

Takeaways:

variable can include multiple format characters which can be defined within ()

%r will place anything integer or string.

If you place ' in a string %r will handle it by placing it inside ' instead of "

Learn Python the Hard Way

Exercise 7: More printing

takeaways:

a format character can include a string

you can multiply a string to print it multiple times.

a comma at the end of a print will put the next statement on the same line.

Learn Python the Hard Way

Exercise 6: Strings and Text

Takeaways:

you can call a string within a string.

A string is usually a bit of text you want to display to someone, or "export" out of the program you are writing. Python knows you want something to be a string when you put either " (double-quotes) or ' (single-quotes) around the text. You saw this many times with your use of print when you put the text you want to go to the string inside " or ' after the print. Then Python prints it.

Strings may contain the format characters you have discovered so far. You simply put the formatted variables in the string, and then a % (percent) character, followed by the variable. The only catch is that if you want multiple formats in your string to print multiple variables, you need to put them inside ( ) (parenthesis) separated by , (commas). It's as if you were telling me to buy you a list of items from the store and you said, "I want milk, eggs, bread, and soup." Only as a programmer we say, "(milk, eggs, bread, soup)".

Learn Python the Hard Way

Exercise 5: More Variables and printing

Takeaways:

you can use format characters to place variables in print strings

%r will put ' around the variable but will print anything no matter what.

Format character list: http://docs.python.org/release/2.5.2/lib/typesseq-strings.html

%d and %i - signed integer decimal

%o and %u - Unsigned octal

%x and %X - Unsigned hexadecimal (lowercase and uppercase respectively)

%e and %E - Floating point exponential format (lowercase and uppercase respectively)

%f and %F - Floating point decimal format

%g and %G - Floating point format. Uses exponential format if exponential format is greater than -4 or less than precision, decimal format otherwise.

%c - Single character (accepts integer or single character string)

%r - String (converts any python object using repr())

%s - String (converts any python object using str())

% - No argument is converted, results in a "%" character in the result.

Learn Python the Hard Way

Exercise 4: Variables and Names

takeaways:

variables are simply typed out: name = 200 (the equal sign makes names for things)

Simply call on the variable by typing it out

to print a variable in a sentence be sure to call it outside of the "

Learn Python the Hard Way

Exercise 3: Numbers and Math

Takeaways:

+ plus - Addition

- minus - Subtraction

/ slash - Divide

% percent - print

* astrick - percentage

< less than

> greater than

<= less than equal

> greater than equal

doing math inside print does nothing but print the problem.

a coma [,] after the print " puts the equation on the same line.

always read a percentage like this: 4 % 5 "4 percent of 5"

to print the answer when you run the code use print at the beginning of the line.

Run python and you can start typing in python commands direct.

use ctrl + d to exit python

To use the floating point (Significant digits × baseexponent) write your number out like: 2.0

More on Floating points: The advantage of floating-point representation over fixed-point andinteger representation is that it can support a much wider range of values. For example, a fixed-point representation that has seven decimal digits with two decimal places, can represent the numbers 12345.67, 123.45, 1.23 and so on, whereas a floating-point representation (such as the IEEE 754 decimal32 format) with seven decimal digits could in addition represent 1.234567, 123456.7, 0.00001234567, 1234567000000000, and so on. The floating-point format needs slightly more storage (to encode the position of the radix point), so when stored in the same space, floating-point numbers achieve their greater range at the expense of precision. -- http://en.wikipedia.org/wiki/Floating_point

Learn Python the Hard Way

Exercise 2: Comments and Pound Characters

Takeaways:

# at the beginning of a line will start a comment.

# anywhere in a line will start a comment AFTER the #

Learn Python the Hard Way

Exercise 1 - A good program.

Takeaways:

print with closed " or ' will display a line

to use a " within your line you must begin and end with '

to use ' start and end with "

# starting with this (an octothorpe) is makes that line as a comment in the code

Win Without Pitching (WWP) Notes: chapter 3

We Will Diagnose Before We Prescribe

Never agree to begin working on a creative solution to a problem that we have not fully explored.

There are four phases in our client engagements:

1. Diagnose the problem/opportunity

2. Prescribe a therapy

3. Apply the therapy

4. Reapply the therapy as necessary

While it is common practice in the creative professions to prescribe solutions without fully and accurately diagnosing the problem, in almost every other profession such a sequence would render the professional liable for malpractice.

process that pits multiple firms against each other and asks each to present solutions, the client does not have the time to invest in meaningful diagnostics with them all. So he abbreviates the diagnostic phase; he dictates the process, marginalizes it and proclaims that his self-diagnosis is valid enough for us to proceed.

When the client comes to us self-diagnosed, our mindset must be the same as the doctor hearing his patient tell him what type of surgery he wants performed before any discussion of symptoms or diagnoses. Our reaction must be, “You may be correct, but let’s find out for sure.”

The Practitioner's Perspective

One of the advantages the outside expert brings is perspective. And one of the hallmarks of creativity is the ability to see problems differently, and thus find solutions others cannot see.

Design is not the solution—it is the process.

To reverse the trend and live up to our professional obligation to diagnose first, we must map out and formalize our own diagnostic process.

Then, when we are next in a situation where the prospective client is dictating to us, we must make the case that the consistency of our outcomes is rooted in the strength of our process, therefore we must be allowed to employ it.

Learning From Other Professionals

Other professionals do not suffer nearly as much as us in being dragged into engagements where the client or patient has been allowed to dictate the diagnostic process. Interestingly, many of us have discovered that these other professionals make the worst clients. The reason they avoid the problem we do not, and then create problems for us when they become our clients is the same: they take control.

The Root of Bad Engagements

When we think back now on our worst client experiences we can see that most of them were rooted in this mistake of letting a dominant client direct the engagement, beginning with a self-diagnosis that we took at face value.

He sees us as irresponsible order-takers not worth the money he is paying.

If design truly is a process, then we will define and guard that process and we will walk away from those clients and situations, like the pitch, where the process is dictated to us, or where we are otherwise asked to propose solutions without a proper diagnosis.

The Polite Battle for Control

Throughout the buying cycle we are constantly gauging whether or not the client recognizes and values our expertise to the extent that he is willing to grant us this control.

Possessing our own formalized diagnostic methods, whether they are proprietary to us or not, goes a long way to our positioning in this matter.

A good client will begin to relinquish control once he has the confidence that the expert practitioner knows more than he does, or has the tools to learn more. Formalized diagnostic processes are such tools.

#winwithoutpitching

Win Without Pitching (WWP) Notes: chapter 2

Replace Presentations with Conversations

Even when we pitch and win, we lose. We devalue what should be our most valuable offering and set up the wrong dynamics between the client and us. A successful presentation requires surprise. It depends on a big reveal in the form of a key diagnostic finding, a dramatic strategic recommendation or a novel creative concept that is at odds with expectations or set against a backdrop of uncertainty. At a time when we should be conversing, we are instead cloistered away preparing for the one-way conversation called the presentation.

Step One: Improving Collaboration with Existing Clients

Making the big reveals small and reducing our dependency on the presentation requires us to work more closely with the client. This creates a challenge: how to invite him in without allowing him to drive? This delicate balancing act of bringing him closer without conceding control can only be achieved when we establish and communicate the rules of the engagement.

The Rules of Collaboration

1. Strategy First

We will agree with the client on the strategy before any creative development begins.

2. Continuous Reference to Strategy

keep the discussion around the creative focused and measured against the strategy. Any time we come back to the client to share new ideas or concepts we will set the stage first by reviewing, once again, the strategy that guides us.

3. Freedom of Execution

We welcome the client’s input on the strategy and in exchange we ask him to grant us the freedom to explore various ways of executing it. This means we invite him to say, “That blue isn’t bold enough to deliver on our core value of strength.” But we explain that he is not invited to say, “Make it darker.” The client must ultimately approve of our recommendations, and be satisfied with the outcome, but he must also let us explore along the way.

4. Fewer Options of Better Quality

When we present creative options we will strive to limit them to as few as practical. There is an inverse correlation between the quantity of creative options we present to the client and the confidence we have in their quality. We will NOT ask “Which one do you like?” We will direct all discussions around the creative back to the strategy and ask if we are accomplishing our goals.

5. Only We Present Our Work

Whenever our diagnostic findings, strategic recommendations or creative solutions are presented to anyone in our client companies, it will be personnel from our firm that does so.

Step Two: Eliminating Big Reveals in the Buying Cycle

The presentation seems like a natural and necessary step, until we ponder the question: “How would we conduct ourselves in the meeting if we were not allowed to present?” Without a presentation, all that is left is conversation—intermingled talking and listening un-separated by one party performing for the other.

Presenting is a tool of swaying, while conversing is a tool of weighing. Through the former we try to convince people to hire us. Through the latter we try to determine if both parties would be well served by working together. Presentations build buying resistance; conversations lower it.

what we are trying to accomplish in the buying cycle:

Mission: Position

Our mission is to position ourselves as the expert practitioner in the mind of the prospective client. It is not our job to convince the client to hire us via presentation or any other means.

Objective: Determine Fit

objective at each and every interaction in the buying cycle is simply to see if there is a fit between the client’s need and our expertise suitable enough to take a next step.

Now, the Truth About Presenting

Alas, you may have guessed that we will never be completely free of the presentation. That is not the goal of this, the second proclamation. The goal is to be free of our own need to present.

#winwithoutpitching

Win Without Pitching (WWP) Notes: chapter 1

Specialize - too many choices (legitimate alternative offerings) means we are left explaining and going into too much detail to make a sale. Giving our thinking away for free. Establishing yourself as more expert than the competition is key to dictating pricing, terms and control in a manner that better ensures that our ideas and advice have the desired impact.

Power in the client-agency relationship usually rests with the client. His power comes from the alternatives that he sees to hiring us.

2. Position - drastically reduce the real alternatives to hiring our firm.

Three Steps of Positioning: 1) focus 2) Articulate that focus via a consistent claim of expertise 3) Work to add missing skills, capabilities and processes necessary to support our new claim.

Positioning Benefits: a sales advantage and a price premium.

Winning while charging more is the ultimate benefit and key indicator of effective positioning. The more alternatives the less power we have to command a premium over our competition.

Control: We are hired for our expertise and not our service. “The customer is always right” does not apply to us. Our ability to control the engagement diminishes with time. It is important, therefore, that we enter the engagement with as much control as possible.

The Cost of Creativity

One of the hallmarks of creativity is a fascination with the new and the different. Properly harnessed, this fascination allows us to bring fresh thinking to old problems and ensure that our offerings to our clients are always evolving. Un-harnessed, our firm-wide desire for the new and the different can lead us to avoid positioning.

Fun and Money

There are greater causes by which to frame an enterprise, and there are nobler metrics by which to measure the value of effort. But we cannot escape the fact that money is both a necessity in life and the most basic scorecard of success in business. Even if it is not the validation we seek, it is the most basic of tests that we must pass: Is there a need for our efforts great enough to sustain and nurture them?

#winwithoutpitching

So you want to program? Setting up a Development Environment

How to setup a virtual machine running Linux with Ubuntu 10.04, Python 2.6, MySQL 5.1, Django 1.3 and an IDE (where you will edit your code)- we'll install Komodo edit

You can make a real mess on your computer ("machine"). Add a little padding like a Virtual Machine and you can be fearless in your programing. My OS of choice is Windows Vista 64-bit but I'd like to program on a linux computer. I can do that by installing vmware's Player (https://www.vmware.com/tryvmware/index.php)

Now I want to use Linux with Ubuntu 10.04 (the current stable version for 64-bit). So I went to http://www.ubuntu.com/desktop/get-ubuntu/download and downloaded that. Note do NOT install this after it's done downloading.

Now open up the vmware player and click "Create a New Virtual Machine" you'll have three options 1) installer disc 2) Installer disc image file (iso) and 3) install the operating system later.

Select #2 Installer disc image this is the file you just downloaded from the ubuntu site.

Hit next and let the program walk you through install. Afterwards you should see a slick purple OS that looks reassuringly similar to your windows OS (although it looks even more like a Mac OS).

Python 2.6 and MySQL 5.1 are fully supported by Ubuntu 10.04 which means 1) they are already installed and ready to go 2) They are stable. Yes there are newer versions of both but if you want to work on, or build, mission critical applications (such as Finance industries handling $billions) stick with what is fully supported and 3) It's also worth it to note Django does not yet work with python versions over 2.7 and just dropped support with python 2.3

So how do you install Django? Go to http://www.djangoproject.com/download/ -- right click on the link for downloading django 1.3 and select "copy link location" Now you have the url to the download location. Go to your applications tab on the top left, click accessories and click terminal. Now type:

wget "right click and select paste this is where the url to the django download will go"

unpack the zip file (tar.gz) in the terminal by typing:

tar zxvf "the file name goes here - can't recall what it is? Look at that url you pasted usually the file name is exactly the last part of it after the last /"

Now tell the terminal to go into the directory where you unpacked the zip file (tar.gz) and install django

cd "This is the name of the zip file without tar.gz at the end"

sudo python setup.py install

Verify that the django install took type

python

import django

print django.get_version()

If it installed you'll see a new line: 1.3

So to recap this should be what you typed into your terminal:

wget http://www.djangoproject.com/download/1.3-rc-1/tarball/

tar zxvf Django-1.3-rc-1.tar.gz

cd Django-1.3-rc-1

sudo python setup.py install

python

import django

print django.get_version()

To install your IDE (I chose Komodo Edit a free editor) you almost replicate the same steps in your terminal. o to http://www.activestate.com/komodo-edit/downloads and copy the link location for the download. In your terminal type:

wget http://downloads.activestate.com/Komodo/releases/6.1.1/Komodo-Edit-6.1.1-7295-linux-libcpp6-x86_64.tar.gz

tar zxvf Komodo-Edit-6.1.1-7295-linux-libcpp6-x86_64.tar.gz

cd Komodo-Edit-6.1.1-7295-linux-libcpp6-x86_64

sh install.sh

You'll notice the difference is the sh command this is telling the terminal that you want to run a shell script. This will prompt you to pick a directory to install your program to. Just hit enter and the directory will be ~/ or you can specify something like: /home/userul_meu/SoftInstalat/Komodo

Your installation should be complete! You'll see on your desktop an icon for komodo but if you want to be super geeky start the editor from your terminal with this command:

sudo In -s “/home/ducu/SoftInstalat/Komodo/bin/komodo” /usr/local/bin/komodo

And that completes my simple crash course tutorial.

#python #django #ubuntu #linux #virtual machine #vmware #mySQL

Getting Started with Git and GitHub

About Git: is a distributed revision control system with an emphasis on speed. Every Git working directory is a full-fledged repository with complete history and full revision tracking capabilities, not dependent on network access or a central server.

About Github: is a web-based hosting service for projects that use the Git revision control system. The site provides social networking functionality such as feeds, followers and the network graph to display how developers work on their versions of a repository.

Getting Started with Version Control (VC):

VC is the process of recording the history of changes to files as they are modified. Users can go back in time and get old versions and identify where changes were introduced.

Benefits:

protect against changes—accidental or otherwise—and be able to access a known good version of a file

track down problems and make fixes to previous versions of files

allow more than one person to modify project files simultaneously (programmers refer to this as parallel development)

retrieve an older set of files (if requested by a customer or manager, for example)

Git represents the current state of VC, in that: it is distributed. A distributed VC tool gives each user a complete history of all changes to the files on which they work. So no matter where you are you can access previous versions of files and changes can be merged together for release or further work.

Git is different from VC tools because it is distributed. Other VC tools are centralized and provide only a single place, the repository, into which users store their changes on a regular basis. In this model users work without a personal copy of the change history; they only have the set of the files they’re currently working with.

Concepts:

Repo: Git maintains a database of all previous file versions in a repository usually located in a directory called .git. this includes contents of the files, directory versions and additional housekeeping information about current work, other remote repositories we’re sharing with, current settings, and so on. In Git we have a separate repo for each of our projects.

In UNIX-style systems (like Mac OS X and Linux) names that begin with a . are hidden by default so the repo is usually invisible during normal work (except on Windows).

Committing changes: Each project will have a set of files that we’re working on and editing. As we complete changes to our working files we add the changes to the repo; this is called committing changes. We’re not fully committed to our changes as we can always retrieve old versions and make changes to the changes. We can also access a summary of our work against previous versions to see what we’ve done so far.

Working copy: The set of files we’re currently working on. We can easily change the working copy to a different version whenever we want.

Installing Git

Before going further let’s install Git and set up a small test repo to work with.

Linux: simple matter of using your package manager to install git (and possibly Git GUI if it is a separate package).

Mac OS X either use the Git OSX Installer or you can use Mac Ports.

Windows: users who use Cygwin can use the Git from Cygwin; Otherwise Windows users should use the the native Windows Git package: msysgit

I installed Git and Github on Ubuntu: http://help.github.com/linux-git-installation/

Starting to Use Git

The quickest way to get started is to use the Git GUI client. Type the command git gui at the command prompt.

Select Create New Repository.

Enter the name of a new directory.

Git will create the directory and initialize an empty repo.

To create a project directory, the command prompt is:

$ git init

You should then see a message like the following:

Initialized empty Git repository in /path/to/your/directory/.git/

If you look in the project directory you should see a directory named .git (on Mac OS X or Linux you will need to use the command ls -A to show the hidden .git directory) In your newly created project directory make some new text files using your favorite editor. You now have some changes that are not under version control, in Git these are called unstaged.

You can retrieve the same information from the command line with the command git status.

the Git index:

Git is a little different to most VC tools. Adding changes to a repo is a two stage process. All changes are staged in the index, before they’re committed into the repo.

The index allows us to add, remove and modify changes on the way to building a commit. useful for:

Our working copy may contain more that one set of changes and the index allows us to cherry pick which ones will be part of the next commit.

You can incrementally make changes (using your own workflow) before making a commit.

You’re able to stage and unstage changes in more complex work flows

git add command is used to add the content to the index.

git rm command is used to remove files

git mv moves or renames files.

Configuration:

Before using Git we need to tell Git who we are; our name and email address. From the Git GUI interface select Edit > Options and fill in the top two fields under Global. Leave all the other values as they are.

OR from the command line:

$ git config --global user.name "John Doe" $ git config --global user.email "[email protected]"

Committing Changes:

Now we can add our changes to the index and commit them to the repository. First select both files on the Unstaged Changes pane.

Then select Commit > Stage To Commit (ctrl+T). The display then shows that we have no changes waiting to be staged, but we do have changes to be committed.

OR in the command line:

$ git add file1 file2

If it’s unnecessary to specify which files to add:

$ git add .

Now that our files are staged, we can commit our first changes to the repo. Each time we make a commit, Git expects an informational message that’s added as part of the commit; if fail to provide a message no commit will be made. Generally we add a single line description and then a more detailed message. Click theCommit button and the changes are committed to the repo.

OR in the command line:

$ git commit -m "A message about your changes"

HEAD:

The latest version in the repo—called HEAD—is the same as the contents of the working files. Running the command git status should show the message:

$ git status # On branch master nothing to commit (working directory clean)

We can always refer to the contents of the last commit as HEAD and the contents of the commit prior to that as HEAD^1 (and HEAD^2 for the commit prior to that, and so on). However that quickly becomes error prone and hard to use, so Git gives each commit a special id which is an apparently random string of 40 characters called the sha1 hash. It looks a like this: a90973cbe16d5a0cf4fcd5cca659f4a4587d7cb5.

Every commit across the world has a unique sha1 hash and when you come to share your history with other Git users (for instance, other members of the web team) it’s a unique way to refer to your work and its history. If two users have the same sha1 in their repo then they are referring to the same piece of work. In practice, humans can usually just refer to the last few unique digits in the sha1 to uniquely identify a commit.

As a user you’ll generally only see a sha1 hash used to represent a commit; however, “under the covers” the hash is used to identify files and directories (which form trees in Git terminology), and other objects. This has an interesting, and highly desirable, effect. When you rename a file (or move it in the directory tree) its sha1 hash remains unchanged, but the tree that refers to the file and its name changes. This means that Git can track changes and moves far more easily than tools such as Subversion.

Pretend you’ve done some work and make a change to one of the files. Git GUI will show you the changes.

OR the command line:

git diff

to show the changes.

To view the history of commits to a project:

git log

Git also has a second GUI application called gitk that displays the history of commits in a graphical format. In Git GUI select Repository > Visualize All Branch History.

Notes from: http://help.github.com/ and http://articles.sitepoint.com/article/version-control-git

#git #github

Sass – Syntactically Awesome Stylesheets

About: Sass is an extension of CSS3 a meta-language on top of CSS used to describe the style of a document cleanly and structurally, with more power than flat CSS allows.

Adds nested rules, variables, mixins, selector inheritance and more.

Has 2 syntaxes:

Sass3 is known as SCSS which is a superset of CSS3. Meaning every valid CSS3 stylesheet is valid SCSS. SCSS files use the extension .scss

An older syntax is “indented syntax” or Sass. Inspired by Haml it is intended for conciseness over similarity to CSS. No brackets or semicolons are used just indentation. Files use the extension .sass

Sass is primarily used as a Rails plugin but the Ruby gem makes it possible to use from the command line so it is easy to use with any language (python and even HTML)

For tutorial Read: http://wiseheartdesign.com/articles/2010/01/18/the-demise-of-css-why-sass-and-languages-like-it-will-triumph/

#Sass #CSS #StyleSheets #Python

HamlPY

A Python implementation of Haml – not a template engine itself but more of a compiler which converts a Haml like syntax into Django templates. So I’m back to the Haml tutorial… (install HamlPy on github: https://github.com/jessemiller/HamlPy)

How to convert existing files (haml – assumes your using rails but should work for other frameworks and standalone Haml):

Trending Blogs

Recently Viewed Blogs

Spark U