I have 6 genes of Candida albicans yeast namely orf19.723, orf19.5908, orf19.610, orf19.2119, orf19.4998 and orf19.4056. And I have found the corresponding ortholog genes from Broad Institute website of other 16 species of yeast. So I have all gene names. Now how would I specifically download these genes and from where can I do this, preferably in an automated manner?

Also is there any standard naming convention? Because the ORF names given have other names too like BCR1, EFG1 and NDT80.

The list of gene names I have :

The orthologs of C. Albicans with S. cerevisiae
orf19.2119  YHR124W 
orf19.4998  YBR033W YKL034W 
orf19.5908  YBR083W 
orf19.610   YMR016C YKL043W 
orf19.723   NONE
orf19.4056  YMR136W 

The orthologs of C. Albicans with S. paradoxus
orf19.2119  spar33-g1.1 
orf19.4998  spar197-g23.1   spar324-g3.1    
orf19.5908  spar200-g4.1    
orf19.610   spar184-g1.1    spar324-g10.1   
orf19.723   NONE
orf19.4056  spar165-g2.1

The orthologs of C. Albicans with S. mikatae
orf19.2119  NONE
orf19.4998  smik146-g12.1   smik109-g17.1   
orf19.5908  smik83-g2.1 
orf19.610   smik571-g2.1    smik109-g10.1   
orf19.723   NONE
orf19.4056  smik1535-g1.1   

The orthologs of C. Albicans with S. bayanus
orf19.2119  sbayc514-g9.1   
orf19.4998  sbayc611-g22.1  sbayc652-g20.1  
orf19.5908  sbayc678-g131.1 
orf19.610   sbayc638-g23.1  sbayc652-g27.1  
orf19.723   NONE
orf19.4056  sbayc657-g41.1

The orthologs of C. Albicans with S. castellii
orf19.2119  Scas697.24  
orf19.4998  Scas625.4   
orf19.5908  Scas718.27  Scas635.12  
orf19.610   Scas106.1   Scas709.52  Scas625.8   
orf19.723   NONE
orf19.4056  Scas680.22d 

The orthologs of C. Albicans with C. glabrata
orf19.2119  CAGL0L13090g    
orf19.4998  CAGL0L01947g    
orf19.5908  CAGL0M01716g    CAGL0F04081g    
orf19.610   CAGL0M07634g    CAGL0L01771g    
orf19.723   NONE
orf19.4056  CAGL0I00902g    CAGL0L06776g    

The orthologs of C. Albicans with S. kluyveri
orf19.2119  SAKL0E11330g    
orf19.4998  SAKL0A09812g    
orf19.5908  SAKL0B06578g    
orf19.610   SAKL0D13442g    
orf19.723   SAKL0A03476g    
orf19.4056  SAKL0E04862g    

The orthologs of C. Albicans with K. lactis
orf19.2119  KLLA0F24420g    
orf19.4998  KLLA0F25674g    
orf19.5908  KLLA0E12507g    
orf19.610   KLLA0F04840g    
orf19.723   NONE
orf19.4056  KLLA0F17116g    

The orthologs of C. Albicans with A. gossypii
orf19.2119  AGR347W 
orf19.4998  AFR275W 
orf19.5908  AER177W 
orf19.610   ABR055C 
orf19.723   NONE
orf19.4056  ADR249W 

The orthologs of C. Albicans with K. waltii
orf19.2119  Kwal33.14699    
orf19.4998  Kwal26.8099 
orf19.5908  Kwal27.12423    
orf19.610   Kwal26.8176 
orf19.723   NONE
orf19.4056  Kwal47.17849    

The orthologs of C. Albicans with C. tropicalis
orf19.2119  CTRG01097.3 
orf19.4998  CTRG03636.3 
orf19.5908  CTRG02294.3 
orf19.610   NONE
orf19.723   CTRG00608.3 
orf19.4056  CTRG04523.3 

The orthologs of C. Albicans with L. elongosporus
orf19.2119  LELG01178   
orf19.4998  NONE
orf19.5908  LELG02666   
orf19.610   LELG05390   
orf19.723   LELG03123   
orf19.4056  LELG01761   

The orthologs of C. Albicans with C. parapsilosis
orf19.2119  CPAG04608   
orf19.4998  NONE
orf19.5908  CPAG01691   
orf19.610   CPAG00178   
orf19.723   CPAG00564   
orf19.4056  CPAG05034   

The orthologs of C. Albicans with D. hansenii
orf19.2119  DEHA2A07282g    
orf19.4998  NONE
orf19.5908  DEHA2G13794g    
orf19.610   DEHA2E10978g    
orf19.723   DEHA2E05984g    
orf19.4056  DEHA2E07172g    DEHA2F25916g    

The orthologs of C. Albicans with C. guilliermondii
orf19.2119  PGUG02096.1 
orf19.4998  NONE
orf19.5908  PGUG04378.1 
orf19.610   PGUG03651.1 
orf19.723   PGUG05571.1 
orf19.4056  PGUG05533.1 

The orthologs of C. Albicans with C. lusitaniae
orf19.2119  CLUG00404   
orf19.4998  NONE
orf19.5908  CLUG04694   
orf19.610   CLUG02047   
orf19.723   CLUG00627   
orf19.4056  CLUG05535



Question: Should FPS exceed ticks/second?
Answer: Your engine and your game must be super flexible to allow the possibility of drawing two times with no state change.
A usual game loop ties very closely all updates in a sequential fashion.
One thread, one loop, one point to flush events, one point to execute processing updates (entity/component processors, or simply manager's updates), and finally one render call which triggers the whole engine 1-frame render.  

Whole engine 1 frame render can be made in two fashions, extrospective (intrusive), by accessing (with visitors) the state of the drwable objects of the game, and create the rendering states, passes and commands that go with it.

Or it could be fully retained, and the state of the engine was set BY the processors during the logic update, and it holds sufficient information per se to draw a frame in isolation.

This is a classical game loop. It uses a delta_time variable that is given to all managers during update.

If you have a physical manager, usually there is another loop within the Update itself, that will use a fixed dt and iterate as many time to fill the lagging-time to reach delta_time. And store the remainder for the next frame's refresh, to execute as part of the first loop next time.

Now, its possible to have a more advanced game loop by separating event treatments, by using a thread specific system event queue, preparing a pool of timestamped events, and when the main thread is in the event treatment update, it pulls this queue.

Its hardly possible to completely asychronize managers updates and frame rendering. Many engine state updates are not atomic. Even a fully retained engine will have limitations. DirectX11 introduces isolated command lists (deferred devices, in their parlance), which can help to design such an engine. But if you have such basic doubts about your own render loop, I suppose you don't use such things, yet.

Since you are in java, and you talk about ticks, I imagine you must have plugged your refresh function to a periodic timer. Of course this is sub-par as a game loop design, even from the most basic loop design described above. This is not how real time systems are designed, doing this, you rely on a framework, that depends on operating system native kernel tick rate, and java's virtual machine to relay you the wakening events (and scheduling) to fire up your frame routine. This will incur bad sampling rates (aliasing) and randomness from various sources. You will have to suffer from potentially long sleep times that are not controlled, in the thread ready queue, or kernel timer tick rounding issues. This will all misalign with your framerate presentation, and result in stutterings, and if the event queue is not fully depleted at each refresh, you will also have input lag, and potentially, building up with time. Worse, since you are event based, your events I fear, are consumed by event treatment, therefore your processing time will vary according to input, and delay your frame rendering. Potentially totally masking it out. This is like a security flaw, lots of input could overflow the game and make it unresponsive.

Event based systems are not made for real time applications, they are made for basically idling applications.

Now, back to your question, it should not be a problem to fraw at 40FPS when your game updates at 20. Also be careful, in a timer based system, 20 FPS = 50ms, it will likely round up to 60ms (4*15 ; 15=typical kernel), therefore you'll get 16FPS. Use some precise chronometers to display frame update time on screen, and another one to display display rate. (use a counter around the Present call. Or framebuffer Swap (OpenGL term), or simply install Fraps.)

This will give you some statistics.

The people advocating that high display rates are bad probably refer to useless loss of resource, resulting in machine heating up, or the useless frame taking time to finish, the GPU is not ready to render the next frame when its ready, that is to say, likely right in the middle of the useless redraw. Which is why, no redraw = better responsiveness, leaving the GPU available right away when the next frame is ready.

Also tearing, is an argument often heard. Tearing is caused by swappings (presentations) frequencies that are non multiples of the screen frequency. the VSynch is the feature that helps that, by using hardware support, the VGA/DVI/HDMI cable transports a tick signal that says "I flipped!", the graphic cards receives it, signal it to the CPU with an interrupt (most likely), and the driver gets it and communicate it to the currently waiting OpenGL/DirectX presenting threads. This unleash a fast back-to-front copy, which executes in much less that the 60Hz timeframe, and then when the screen next flips, a full image is presented, this avoids perfectly the tearing.

The best is to respect this presentation rate, it is a tempo given by hardware, and the whole game/engine thread is put to sleep by the graphics API itself inside of the Swap/Present call, which allows to rest the CPU, allowing it to cool down, and allows perfect frame/game synchronization if using a linear loop like mentioned above.

Provided your game can update faster than 60Hz. Otherwise, it will fallback immediately to 30Fps naturally, then 20, then 15, by plateaus. This is a natural response.