Sight is one of the senses most programmers take for granted. Most programmers would spend hours looking at a computer monitor (especially during times when they are *in the zone*), but I know there are blind programmers (such as T.V. Raman who currently works for Google).

If you were a blind person (or slowly becoming blind), how would you set up your development environment to assist you in programming?

(One suggestion per answer please. The purpose of this question is to bring the good ideas to the top. In addition, screen readers can read the good ideas earlier.)

How can you program if you&#39;re blind?

Our company is currently using a simple trunk/release/hotfixes branching model and would like advice on what branching models work best for your company or development process.

 1. **Workflows / branching models**

 Below are the three main descriptions of this I have seen, but they are partially contradicting each other or don&#39;t go far enough to sort out the subsequent issues we&#39;ve run into (as described below). Thus our team so far defaults to not so great solutions. Are you doing something better? 
 
  - [gitworkflows(7) Manual Page][2] 
  - [(nvie) A successful Git branching model][3]
  - [(reinh) A Git Workflow for Agile Teams][4]

 1. **Merging vs rebasing (tangled vs sequential history)** 

 Should one `pull --rebase` or wait with merging back to the mainline until your task is finished? Personally I lean towards merging since this preserves a visual illustration of on which base a task was started and finished, and I even prefer `merge --no-ff` for this purpose. It has other drawbacks however. Also many haven&#39;t realized the useful property of merging - that it isn&#39;t [commutative][5] (merging a topic branch into master does not mean merging master into the topic branch).

 1. **I am looking for a natural workflow** 

 Sometimes mistakes happen because our procedures don&#39;t capture a specific situation with simple rules. For example a fix needed for earlier releases should of course be based sufficiently downstream to be possible to merge upstream into all branches necessary (is the usage of these terms clear enough?). However it happens that a fix makes it into the master before the developer realizes it should have been placed further downstream, and if that is already pushed (even worse, merged or something based on it) then the option remaining is cherry-picking, with its associated perils. What simple rules like such do you use? *Also in this is included the awkwardness of one topic branch necessarily excluding other topic branches (assuming they are branched from a common baseline). Developers don&#39;t want to finish a feature to start another one feeling like the code they just wrote is not there anymore*

 1. **How to avoid creating merge conflicts (due to cherry-pick)?** 

 What seems like a sure way to create a merge conflict is to cherry-pick between branches, they can never be merged again? Would applying the same commit in revert (how to do this?) in either branch possibly solve this situation? This is one reason I do not dare to push for a largely merge-based workflow.

 1. **How to decompose into topical branches?** 

 We realize that it would be awesome to assemble a finished integration from topic branches, but often work by our developers is not clearly defined (sometimes as simple as &quot;poking around&quot;) and if some code has already gone into a &quot;misc&quot; topic, it can not be taken out of there again, according to the question above? How do you work with defining/approving/graduating/releasing your topic branches?

 1. **Proper procedures like code review and graduating** would of course be lovely. 
 
 But we simply cannot keep things untangled enough to manage this - any suggestions?
integration branches, illustrations?

Below is a list of related questions:

 - [What are some good strategies to allow deployed applications to be hotfixable?][6]
 - [Workflow description for Git usage for in-house development][7]
 - [Git workflow for corporate Linux kernel development][8]
 - [How do you maintain development code and production code?][9] (thanks for [this][10] PDF!)
 - [git releases management][11]
 - [Git Cherry-pick vs Merge Workflow][12]
 - [How to cherry-pick multiple commits][13]
 - [How do you merge selective files with git-merge?][14]
 - [How to cherry pick a range of commits and merge into another branch][15]
 - [ReinH Git Workflow][16]
 - [git workflow for making modifications you’ll never push back to origin][17]
 - [Cherry-pick a merge][18]
 - [Proper Git workflow for combined OS and Private code?][19]
 - [Maintaining Project with Git][20]
 - [Why cant Git merge file changes with a modified parent/master.][21]
 - [Git branching / rebasing good practices][22]
 - [When will &quot;git pull --rebase&quot; get me in to trouble?][23]
 - [How are DVCS used in large teams?][29]

Also check out what Plastic SCM writes on [task driven development][26], and if Plastic is not your choice, study [nvie&#39;s branching model][27] and his [supporting scripts][28].



  [2]: http://www.kernel.org/pub/software/scm/git/docs/gitworkflows.html
  [3]: http://nvie.com/git-model
  [4]: http://reinh.com/blog/2009/03/02/a-git-workflow-for-agile-teams.html
  [5]: http://en.wikipedia.org/wiki/Commutativity
  [6]: https://stackoverflow.com/questions/143814/what-are-some-good-strategies-to-allow-deployed-applications-to-be-hotfixable
  [7]: https://stackoverflow.com/questions/1049917/workflow-description-for-git-usage-for-in-house-development/1050628
  [8]: https://stackoverflow.com/questions/1856241/git-workflow-for-corporate-linux-kernel-development
  [9]: https://stackoverflow.com/questions/216212
  [10]: https://stackoverflow.com/questions/216212/how-do-you-maintain-development-code-and-production-code/216219#216219
  [11]: https://stackoverflow.com/questions/1042400/git-releases-management
  [12]: https://stackoverflow.com/questions/1241720/git-cherry-pick-vs-merge-workflow
  [13]: https://stackoverflow.com/questions/1670970/how-to-cherry-pick-multiple-commits
  [14]: https://stackoverflow.com/questions/449541/how-do-you-merge-selective-files-with-git-merge
  [15]: https://stackoverflow.com/questions/1994463/how-to-cherry-pick-a-range-of-commits-and-merge-into-another-branch
  [16]: https://stackoverflow.com/questions/855266/reinh-git-workflow
  [17]: https://stackoverflow.com/questions/582015/git-workflow-for-making-modifications-youll-never-push-back-to-origin
  [18]:  https://stackoverflow.com/questions/232771/cherry-pick-a-merge
  [19]: https://stackoverflow.com/questions/2195826/proper-git-workflow-for-combined-os-and-private-code
  [20]: https://stackoverflow.com/questions/2587721/maintaining-project-with-git
  [21]: https://stackoverflow.com/questions/2588824/why-cant-git-merge-file-changes-with-a-modified-parent-master
  [22]: https://stackoverflow.com/questions/2601967/git-branching-rebasing-good-practices
  [23]: https://stackoverflow.com/questions/2590260/when-will-git-pull-rebase-get-me-in-to-trouble
  [24]: http://www.mail-archive.com/dri-devel@lists.sourceforge.net/msg39091.html
  [26]: http://www.plasticscm.com/features/task-driven-development.aspx
  [27]: http://nvie.com/posts/a-successful-git-branching-model/
  [28]: https://github.com/nvie/gitflow
  [29]: https://stackoverflow.com/questions/787638/how-are-dvcs-used-in-large-teams

What Git branching models work for you?

I have my `master` branch and a `develop` branch for working on a few changes. I need to merge changes from `master` into `develop`, but will eventually merge everything from `develop` into `master`. I  have two different workflows in mind:

1. `git pull origin master` into `develop` branch
2. `git merge master` into `develop` branch

Which is the best way to do this, and why?

&quot;git pull&quot; or &quot;git merge&quot; between master and development branches

## Problem

Is there any way in Airflow to create a workflow such that the number of tasks B.* is unknown until completion of Task A? I have looked at subdags but it looks like it can only work with a static set of tasks that have to be determined at Dag creation.

Would dag triggers work? And if so could you please provide an example.

I have an issue where it is impossible to know the number of task B&#39;s that will be needed to calculate Task C until Task A has been completed. Each Task B.* will take several hours to compute and cannot be combined.

                  |---&gt; Task B.1 --|
                  |---&gt; Task B.2 --|
     Task A ------|---&gt; Task B.3 --|-----&gt; Task C
                  |       ....     |
                  |---&gt; Task B.N --|
                   
## Idea #1

I don&#39;t like this solution because I have to create a blocking ExternalTaskSensor and all the Task B.* will take between 2-24 hours to complete. So I do not consider this a viable solution. Surely there is an easier way? Or was Airflow not designed for this?

    Dag 1
    Task A -&gt; TriggerDagRunOperator(Dag 2) -&gt; ExternalTaskSensor(Dag 2, Task Dummy B) -&gt; Task C

    Dag 2 (Dynamically created DAG though python_callable in TriggerDagrunOperator)
                   |-- Task B.1 --|
                   |-- Task B.2 --|
    Task Dummy A --|-- Task B.3 --|-----&gt; Task Dummy B
                   |     ....     |
                   |-- Task B.N --|

Edit 1:
-------

**As of now this question still does not have a great answer**. I have been contacted by several people looking for a solution. 

Proper way to create dynamic workflows in Airflow

When I run `git remote -v` in one of my Git repositories that has a remote(s) configured, I see that each remote has both fetch and push specs:

    $ git remote -v
    &lt;remote-name&gt; ssh://host/path/to/repo (fetch)
    &lt;remote-name&gt; ssh://host/path/to/repo (push)

For remotes that point to peer developers there&#39;s no need to push, and Git will refuse to push to a non-bare repository anyway. Is there any way to configure these remotes as &quot;fetch-only&quot; with no push address or capabilities?

Git: Set up a fetch-only remote?

Some things are easier to implement just by hand (code), but some are easier through WF. It looks like WF can be used to create (almost) any kind of algorithm. So (theoretically) I can do all my logic in WF, but it&#39;s probably a bad idea to do it for all projects.

In what situations is it a good idea to use WF and when will it make things harder then they have to be? What are pros and cons/cost of WF vs. coding by hand?

When to use Windows Workflow Foundation?

Interactive Python (ipython) is simply amazing, especially as you are piecing things together on the fly... and does it in such a way that it is easy to go back.

However, what seems to be interesting is the use-case of having multiple ipython notebooks (ipynb files).  It apparently seems like a notebook is NOT supposed to have a relationship with other notebooks, which makes sense, except that I would love to import other ipynb files.

The only workaround I see is converting my *.ipynb files into *.py files, which then can be imported into my notebook.  Having one file hold everything in a project is a bit weird, especially if I want to really push for code-reuse (isn&#39;t that a core tenet of python?).

Am I missing something? Is this not a supported use case of ipython notebooks? Is there another solution I can be using for this import of an ipynb file into another notebook? I&#39;d love to continue to use ipynb, but it&#39;s really messing up my workflow right now :(

Importing an ipynb file from another ipynb file?

I am responsible for a team of developers who will are about to start development of a light weight insurance claims system. The system involves a lot of manual tasks and business workflows and we are looking at using Windows Workflow (.NET 4.0). 

An example of the business domain is as follows:
A policy holder calls the contact centre to lodge a claim. This “event” fires two sub tasks which are manually actioned in parallel and may take a lengthy time to complete;

   1. Check customer for fraud – A manual process whereby an operator calls various credit companies to check and assess the potential of a fraudulent customer. From here the sub task can enter a number of sub-statuses (Check in progress, Failed Reference Check, Passed Reference Check, etc)
   2. Send item to repairs centre – A manual process where the item for which the policy holder lodged the claim is sent the repairs centre to be fixed. From here the sub task can enter a number of sub-statuses (Awaiting Repair, In Progress, Repaired, Posted, etc). 
The claim can only proceed once the status of each sub task has reached a predefined status (based on the business rules). 

On the surface it seems that Workflow is indeed the best technology choice; however I do have a few concerns in using WF 4.0. 

   1. Skill set – Looking at the average developer skill set I do not see many developers who understand or know Workflow.
   2. Maintainability – There seems to be little support within the community for WF 4.0 projects and this coupled with the lack of skill set raise concerns around maintainability.
   3. Barrier to entry – I have a feeling that Windows Workflow has a steep learning curve and it’s not always that easy to pick up.
   4. New product – As Workflow has been completely rewritten for .NET 4.0 I see the product as a first generation product and may not have the necessary stability.
   5. Reputation – Previous versions of Workflow were not well received, considered difficult to develop with and resulted in poor business uptake.

So my question is should we use Windows Workflow (WF) 4.0 for this situation or is there an alternative technology (e.g., [Simple State Machine][1], etc) or even a better workflow engine to use?


  [1]: http://code.google.com/p/stateless/

To Workflow or Not to Workflow?

Is there an easy way to write C code that can access its Git version hash? 

I wrote software in C to collect scientific data in a laboratory setting. My code records the data it collects in a .yaml file for later analysis. My experiments change from day-to-day and I often have to modify the code. To keep track of  revisions, I use a git repository. 

I would like to be able to include the Git revision hash as a comment in my .yaml data files. That way, I could look at the .yaml file and know exactly what code was used to generate the data shown in that file. Is there an easy way to do this automatically? 


How can I get my C code to automatically print out its Git version hash?

I am new to Python as I want to expand skills that I learned using R.
In R I tend to load a bunch of libraries, sometimes resulting in function name conflicts.

What is best practice in Python. I have seen some specific variations that I do not see a difference between

`import pandas`, `from pandas import *`, and  `from pandas import DataFrame`

What are the differences between the first two and should I just import what I need.
Also, what would be the worst consequences for someone making small programs to process data and compute simple statistics.

**UPDATE**

I found this [excellent guide][1]. It explains everything.


  [1]: http://docs.python-guide.org/en/latest/writing/structure/#modules

Importing modules in Python - best practice

I need to reset the iPhone Simulator a lot, and haven&#39;t found a way to do it without using the mouse. It&#39;s a small thing, but I&#39;m really sick of doing it and would love to have a way to do this using a keyboard shortcut.

Even better would be a way to reset it from the command line, so I could build a reset into a deploy script.

I am not very familiar with iOS or MacOS.

How can I reset the iOS Simulator from the command line?

I am developing a ```Gulpfile```. Can it be made to restart as soon as it changes? I am developing it in CoffeeScript. Can ```Gulp``` watch ```Gulpfile.coffee``` in order to restart when changes are saved?

How can Gulp be restarted upon each Gulpfile change?

I am about to learn Emacs, have been through the tutorial and borrowed the O&#39;Reilly book on Emacs. But the question still is - how do you learn good Emacs *workflow*? I guess, you don&#39;t use Emacs as you&#39;d use, for example, [Vim][1].

This question seems revelant to mine:
 - [Where can I find a video of a professional using Emacs?][2]

  [1]: http://en.wikipedia.org/wiki/Vim_%28text_editor%29
  [2]: https://stackoverflow.com/questions/140336



How do you learn proper Emacs?

I just stumbled over something peculiar today. I asked a co-worker at my summer job to help me set up a new remote git repo for my code and there was a lot of confusion about what he did and what I wanted to do. I asked him to send over his config to be able to see the path to his remote and found out that he didn&#39;t have a remote. When I asked him about this he explained his workflow like this:

 1. Change something locally
 2. Commit
 3. Move to remote dir
 4. git pull c:\localdir

So instead of pushing to a remote he constantly pulled from his local repo to the one on our server. Sort of working backwards. When I confronted him about this he asked me what the difference was and I could not really answer him, but I think there are something right?

**So my question to you all is: What is the difference in pushing to a remote and pulling from a remote?**



What is the difference between git push and git pull?

I&#39;m a team leader in our web development company, and I&#39;d like to implement Git workflow in our team. Reading documentation and articles I&#39;ve found the following structure good for us:

We have a repository in a Bitbucket. **Master** branch is considered to contain stable code only. Every dev must create his own branch and implement features/bugfixes in his **own** branch. Once he decides, that his code is ready, he creates a nice branch history (using rebase, amend, cherry-pick etc.) and pushes it to Bitbucket, where creates a pull request to master branch. QA verifies functionality and approves (or disapproves) it, then I&#39;m verifying code and if it is ok, I merge his work into master (by fast-forward or rebasing for better commits history).

But this scheme is good only in a case, when single developer works on a branch. In our case we almost always have two developers for one branch, since one developer is working on *server-side* (PHP), and another - *client-side* (HTML/CSS/JS). How these two should collaborate in a way, that commit history in master stays clean?

Server dev creates basic structure of HTML files and client dev needs to get this structure. Logically would be for server dev to create a branch, and for client dev to create his own branch, based on server dev branch. But this means, that server dev needs to *publish* his branch in Bitbucket, which will make it *impossible for him to rebase or change commits*, that are already published.

Another option is to wait, until server dev finishes his work, publishes branch with nice commits history and forgets about it, and only after that client dev starts to work in this branch, but this will cause time delays, which is even worse.

How do you handle such a collaboration in your workflows?


Proper git workflow scheme with multiple developers working on same task

I am looking to start writing a sophisticated application in JavaScript to run on the web. I&#39;ve written little bits of throwaway code in JavaScript before, using the DOM directly and a little bit of jQuery. But this is the first time I&#39;m looking to write a full-fledged application to run in the browser.

So, I&#39;m wondering what toolchains people prefer for doing serious development in JavaScript. In particular, I&#39;m interested in the following, along with some information about why you chose the components you did and how they all fit together into your workflow:

* What editor and editor plugins/modes/scripts do you use? I&#39;m generally an Emacs user, and am using `js2.el` at the moment, but I&#39;m interested in hearing about other setups.
* Do you use any sort of IDE (Aptana, Dashcode, or the like)?
* What JavaScript libraries or frameworks do you use?
* Do you use any of the languages that compile to JavaScript (GWT, haxe, Objective-J)?
* What unit test frameworks do you use? How do you invoke them? Can they be invoked from your editor/IDE, from the command line, from the browser in a web page, from your JavaScript debugger? 
* What automated user interface testing tools do you use (such as Selenium, Watir, Sahi)? Again, how can these be invoked? (Being able to invoke unit tests and interface tests from the command line would be very useful, for running buildbots)
* What other code quality tools do you use (JSlint, code coverage tools, or anything of the sort)?
* What do you use for your debugging environment (Firebug, WebKit inspector, etc)? Does it have any integration with your editor or IDE?
* What post-processing do you run on your code before deploying it (obfuscators, minifiers, any kind of optimizers)?
* Do you have any sort of tools for managing module dependencies or dynamically loading code as it&#39;s needed? The application I&#39;m writing will be working with a large amount of code, and I would like to keep load times down, so tools for tracking what modules are needed or loading code on demand would be helpful.
* Are there any other essential tools in your toolchain (which are specific to JavaScript development for browser based applications; I already have a perfectly good version control system, bug tracker, etc)?

I&#39;m less interested here in lists of &quot;here are a bunch of things you could use&quot; (I know of a lot of the tools that are available), and more in the stack that you actually use in practice and how it all fits together. I&#39;m hoping to develop this primarily as a client side application, with the server just being used for authentication and to store and retrieve data, so I&#39;m not interested in what server side framework you use, unless it is integral to the client side code in some way.

**edit**: I&#39;m particularly interested in the unit and user interface testing frameworks, and how you automate them. I prefer to be able to run one single &quot;make test&quot; or &quot;rake test&quot; task from the command line to run all tests for the projects, and have it return a status depending on the success or failure of the tests. This would allow much easier integration with buildbots. Also, I&#39;m interested if anyone writes unit tests that can be run outside of a browser (in Rhino, spidermonkey, v8, or the like) for code that don&#39;t depend on the browser, for faster turnaround on a subset of your tests.

What is in your JavaScript toolchain?

Is there an efficient workflow to mirror a project that is mainly hosted on bitbucket using Hg, to github?

Mirroring a HG project from Bitbucket to Github

The `git clone --depth` command option says

    --depth &lt;depth&gt; 
    Create a shallow clone with a history truncated to the specified number of revisions. 
    A shallow repository has a number of limitations 
    (you cannot clone or fetch from it, nor push from nor into it),
     but is adequate if you are only interested in the recent history of a large project with a long history,
     and would want to send in fixes as patches. 

Why do shallow clones have this limitation? Why is it a patches only workflow?


For some project workflows I need to pass just the latest commit from a single branch to a coder, and then have them be able to `push` their (fast forward) developments to the main server. This partly for security, IP protection and repo size, and partly to reduce the confusion that a big repo would bring to a naive coder. Is there a git workflow that allows this?

---
Update: Based on Karl Bielefeldt&#39;s answer the `git checkout --orphan` should be the right answer. But one still needs to &#39;clone&#39; that branch alone to the new user, and be able to push it effectively.

The man page states:
&gt; `git checkout [-q] [-f] [-m] [[-b|-B|--orphan] &lt;new_branch&gt;] [&lt;start_point&gt;] --orphan`
&gt;
&gt; Create a new orphan branch, named `&lt;new_branch&gt;`, started from
&gt; `&lt;start_point&gt;`  and switch to it. The first commit made on this new
&gt; branch will have no  parents and it will be the root of a new history
&gt; totally disconnected from  all the other branches and commits.
&gt; 
&gt; The index and the working tree are adjusted as if you had previously
&gt; run `git checkout &lt;start_point&gt;`. This allows you to start a new
&gt; history that  records a set of paths similar to `&lt;start_point&gt;` by
&gt; easily running `git  commit -a` to make the root commit.
&gt; 
&gt; This can be useful when you want to publish the tree from a commit
&gt; without  exposing its full history. You might want to do this to
&gt; publish an open  source branch of a project whose current tree is
&gt; &quot;clean&quot;, but whose full  history contains proprietary or otherwise
&gt; encumbered bits of code.
&gt; 
&gt; If you want to start a disconnected history that records a set of
&gt; paths that  is totally different from the one of `&lt;start_point&gt;`, then
&gt; you should clear  the index and the working tree right after creating
&gt; the orphan branch by  running `git rm -rf .` from the top level of the
&gt; working tree. Afterwards  you will be ready to prepare your new files,
&gt; repopulating the working tree,  by copying them from elsewhere,
&gt; extracting a tarball, etc.

VonC&#39;s link to Junio&#39;s comments is interesting. I think the manual should provide the guidance in this case, and allow the right command [e.g. `clone &lt;branch&gt; --options`] to extract just the relevant part of the repo. Obviously the probability of `push` success is increased by having a few linked commits and SHA1s at the bottom of the history that will lock down the repo matching.

----
Update Git 1.9.0 : release notes 14 Feb &#39;14.

&quot;Fetching from a shallowly-cloned repository used to be forbidden,
primarily because the codepaths involved were not carefully vetted
and we did not bother supporting such usage. This release attempts
to allow object transfer out of a shallowly-cloned repository in a
more controlled way (i.e. the receiver becomes a shallow repository
with a truncated history).&quot;

This is good news for the shallow cloners.
Next - Narrow clones possibly.


Why can&#39;t I push from a shallow clone?

I have a local branch for day-to-day dev work in git. My workflow is:

 1. Do stuff on local_branch, commit
 1. Fetch origin/master 
 1. Rebase local_branch to catch up with new stuff from origin/master

It all works fine, however most of the recommendations I encountered say that one should not &quot;push&quot; private branches, on which rebase is regularly performed.

The problem here is that in this case local branch is not backed up to a server and the only way to save the work is to merge it back to &quot;pushable&quot; branch (i.e. origin/master)

What would be your recommendations on the workflow in this case? 

Thanks!

**UPDATE**: I realised that one of the original requirements I had (avoiding usage of external utilities) is unnecessary limiting.

My current solution is to store all my repositories in a cloud-synchronised folder - this   way I get backup for free.

How to back up private branches in git

I don&#39;t want to add `schema.rb` to `.gitignore`, because I want to be able to load a new database schema from that file.  However, keeping it checked in is causing all sorts of spurious conflicts that are easily resolved by a fresh `db:migrate:reset`.

Basically I want a way to:

 2. Keep schema.rb in the repository for deploy-time database setup
 3. Keep schema.rb in &#39;.gitignore&#39; for general development

There would be one or two people responsible for updating `schema.rb` and knowing that it was correct.

Is there a way I can have my cake and eat it, too?


What is the preferred way to manage schema.rb in git?

when I put a new DAG python script in the dags folder, I can view a new entry of DAG in the DAG UI but it was not enabled automatically. On top of that, it seems does not loaded properly as well. I can only click on the Refresh button few times on the right side of the list and toggle the on/off button on the left side of the list to be able to schedule the DAG. These are manual process as I need to trigger something even though the DAG Script was put inside the dag folder. 

Anyone can help me on this ? Did I missed something ? Or this is a correct behavior in airflow ?

By the way, as mentioned in the post title, there is an indicator with this message &quot;This DAG isn&#39;t available in the webserver DagBag object. It shows up in this list because the scheduler marked it as active in the metdata database&quot; tagged with the DAG title before i trigger all this manual process.

All Workflow Solutions on Gang of Coders

Total of 21 Workflow Solutions

How can you program if you're blind?