Skip to main content

Home/ Groups/ ProgrammingPages
Navneet Kumar

HTTP/1.1: Method Definitions - 0 views

  • GET and HEAD methods SHOULD NOT have the significance of taking an action other than retrieval.
  •  
    http method definitions. GET, POST, PUT, DELETE, HEAD, TRACE, CONNECT
Thiyagarajan Sadasivam

The best intro book for any topic | BestIntroBook.com - 3 views

  •  
    Site that lists the best intro books for many subjects
Navneet Kumar

Synchronization and the Java Memory Model - 3 views

    • Navneet Kumar
       
      Assignment to a long, double, float variables are not Atomic.
  • as-if-serial property of these manipulations shields sequential programmers from needing to know if or how they take place. Programmers who never create their own threads are almost never impacted by these issues
  • All changes made in one synchronized method or block are atomic and visible with respect to other synchronized methods and blocks employing the same lock, and processing of synchronized methods or blocks within any given thread is in program-specified order. Even though processing of statements within blocks may be out of order, this cannot matter to other threads employing synchronization.
  • ...6 more annotations...
  • atomicity alone does not guarantee that you will get the value most recently written by any thread. For this reason, atomicity guarantees per se normally have little impact on concurrent program design
  • you will obtain either its initial value or some value that was written by some thread, but not some jumble of bits resulting from two or more threads both trying to write values at the same time
  • releasing a lock forces a flush of all writes from working memory employed by the thread, and acquiring a lock forces a (re)load of the values of accessible fields. While lock actions provide exclusion only for the operations performed within a synchronized method or block, these memory effects are defined to cover all fields used by the thread performing the action.
  • If a field is declared as volatile, any value written to it is flushed and made visible by the writer thread before the writer thread performs any further memory operation (i.e., for the purposes at hand it is flushed immediately). Reader threads must reload the values of volatile fields upon each access.
  • Thread.start has the same memory effects as a lock release by the thread calling start, followed by a lock acquire by the started thread
  • As a thread terminates, all written variables are flushed to main memory.
Navneet Kumar

SitePoint CSS HTML DOM Reference - 1 views

  •  
    SitePoint Reference
Thiyagarajan Sadasivam

Essential Vim - 0 views

  •  
    Essential keyboard shortcuts and commands for VIM
Thiyagarajan Sadasivam

mercurial_workflow_image - 1 views

  •  
    mercurial workflow
Navneet Kumar

MySQL Performance Blog ยป MySQL Query Cache - 0 views

  • It does not cache the plan but full result sets
  • so it looks at first letter of the query and if it is โ€œSโ€ it proceeds with query lookup in cache if not - skips it.
  • Might not work with transactions
  • ...15 more annotations...
  • uses non-deterministic functions such as UUID(), RAND(), CONNECTION_ID() etc it will not be cached.
  • If table gets modification all queries derived from this table are invalidated at once
  • if you have high write application such as forums, query cache efficiency might be pretty low due to this.
  • all queries are removed from cache on table modifications - if there are a lot of queries being cached this might reduce update speed a bit
  • Qcache_free_memory and Qcache_lowmem_prunes
  • number of your selects - Com_select and see how many of them are cached. Query Cache efficiency would be Qcache_hits/(Com_select+Qcache_hits).
  • One portion of query cache overhead is of course inserts so you can see how much of inserted queries are used: Qcache_hits/Qcache_inserts Other portion of overhead comes from modification statements which you can calculate by (Com_insert+Com_delete+Com_update+Com_replace)/Qcache_hits
  • want to set query cache
  • means it is much more efficient as query which required processing millions of rows now can be instantly summoned from query cache
  • It also means query has to be exactly the same and deterministic, so hit rate would generally be less
  • full page caching
  • not using query_cache_wlock_invalidate=ON locking table for write would not invalidate query cache so you can get results evenif table is locked and is being prepared to be updated
  • it can serve responses very fast doing no extra conversion or processing.
  • but it is still not as fast as specially designed systems such as memcached or local shared memory.
  • It is not distributed If you have 10 slaves and use query cache on all of them cache content will likely be the same, so you have multiple copies of the same data in cache effectively wasting memory
  •  
    mysql query caching
Navneet Kumar

Generics in C#, Java, and C++ - 1 views

  • And really all they're doing in their implementation is automatically inserting those type casts for you. So you get the syntactic sugar, or some of it at least, but you don't get any of the execution efficiency
  • because Java's generics implementation relies on erasure of the type parameter, when you get to runtime, you don't actually have a faithful representation of what you had at compile time. When you apply reflection to a generic List in Java, you can't tell what the List is a List of.
  • C# does the instantiation at runtime.
Navneet Kumar

Bruce Eckel's MindView, Inc: 3-10-04 Generics Aren't - 0 views

  • Generics seem to only solve the problem of automatically casting in and out of containers.
  • So if we write generic code that actually takes a "type of anything," that type can only be an Object, and our generic code must only call Object methods on it.
  • generics have no advantage. In fact, it's confusing if you see them used, because you scratch your head and wonder "why does he need a generic here? What is the advantage?" Answer: none.
  • ...3 more annotations...
  • Java Generics use "erasure," which drops everything back to Object if you try to say "any type." So when I say <T>, it doesn't really mean "anything" like C++/ADA/Python etc. does, it means "Object."
  • So generics are really "autocasting."
  • That's the way of the Java world, and we are going to miss out on latent typing (it's actually possible to simulate latent typing using reflection, as I do once or twice in Thinking in Java, but it's messy and much less elegant).
  •  
    bruce Eckel article on java generics, and how it does  nothing more than  autocasting. Also templating or parameterized type in C++, Ruby, Python
Navneet Kumar

XSS (Cross Site Scripting) Cheat Sheet - 0 views

  •  
    various ways of XSS
1 - 20 of 97 Next › Last »
Showing 20 items per page