AFAR’s mission is to inspire and guide those who travel the world seeking to connect with its people, experience their cultures, and understand their perspectives. The Digital Content Intern will learn the ins and outs of digital media, and will be a […]

Read more http://ift.tt/1FW846Z

View original post

Website Design Using WordPress

As bloggers, or even better, as writers, we know how important it is to have a hierarchy to your content so our viewers can organize what is important and what is tertiary. In some instances we take it upon ourselves to give our viewer a little help by adding emphasis to some items in our posts, whether by calling them out by using block quotes, adding bulleted or numberor adding a bold or italic type face for content significance. And to be honest, writing your post then adding stylization can take as long as it takes writing your copy.

This is where WordPress Markdown Support comes into play.

WordPress Markdown lets you compose posts and comments with links, lists, and other styles using regular characters and punctuation marks. Markdown is used by writers and bloggers who want a quick and easy way to style their text, without having to take their hands…

View original post 287 more words

Feel free to join

1337632911_Canary Warf_edited-1


When I got this app I were very skeptical, since I just don’t trust the applications that claim to boosts the performance of your device automatically. When it comes to Windows I can do everything myself and better, without any chappy adware. I also of the strong opinion that all performance optimisations have already been made during the OS iClean Master mplementation, so If you are boosting memory by flashing the cache it’s going to lead to slower start ups. While this application claims to do all of that, which I still consider useless it does plenty of other stuff too.

I find it particularly useful for cleaning junk files and identifying and disabling the services you never use. This application is awesome in that! I gives you a ton of options and is a no brainer to use.

That’s it, that is all I care about.

It also claims to cool down the CPU but I’m not sure how it does it since all the decent phones have CPU with variable clock rates. May be its more aggressive in under clocking, I don’t know.

It gets my 4.5 out of 5 for cleaning up junk and a nice interface. Ghee are tons of auxiliary features, but I don’t care about those.

Must have for any Android phone, especially since its free!

How to get it -> Google Play -> “Clear Master”

Disclaimer: I don’t know the author of the software and the review is purely based on my experience. I am in no way standing to benefit from a positive review of the software. This is solely my view of the software and I in no way associated with the developer of the software reviewed.

Weather Balloon Software

Now I’m tempted to go the Android SDK route, it’s free and is more up to date. Apparently Samsung Galaxy Note 3 has quite a few sensors such as temperature, so writing custom software appears to be more tempting

When I comes to hardware there is a lot to think about. I settled on Samsung Galaxy Note 2 because you can plug an external antenna there.The balloon itself would have to be 1.2kg one, this will enable us to have payload of 1/2 a kilo without a problem. I am also thinking a a sun battery, but it could be an over kill, as I plan on adding a duracell pack to the phone. I’m also thinking of a back up comms unit, it could be 4G MiWi, the phone could be paired to it, WiFi requires less power consumption and once it dies it will automatically switch to 4G.

The init will be attached to a parachute, I will also need 5 x 0.41 canisters of helium to give us more than enough payload capacity.


Have to Write my own

Looks like the simplests of things don’t exist on the internet, I just want an application for android that would send pictures to an email address every minute of some as well as the GPS coordinate. Now I had to install Xamarin and figure out how to do it all myself

Also had to splash on one of the books:


Each process has its separate address space. The CLR allocates a segment in memory to store and manage objects. This address space is called managed memory heap as opposed to a native heap. All threads in the process allocate objects on the managed object heap

How Garbage Collection Works

The garbage collection is an automatic process of reclaiming memory from the objects that are no longer in use. It provides several benefits:
· Enables you to develop without having to explicitly fee memory, using ‘delete’ and thus eliminates the potential bugs associated with this manual process whereby a developer deletes and objects still in use or forgets to do so leading to memory leaks

· Significantly improves the allocation performance. In order to allocate an object in CLR world, all the framework has to do is to advance the next object pointer, relying on the fact that the memory is compacted

The garbage collection occurs when the system becomes low on memory; the size of the managed heap surpasses the acceptable threshold or ‘GC.Collect()‘ function is called, triggering the collection.


The managed heap is further segregated into a large object heap LOH and a small object heap. The small object heap is split into 3 generations: Gen0, Gen1 and Gen2 however this depended on the platform, for example if you’re developing using Xamarin for Android you only have 2 generations.

The generations dictate how often the garbage collection is performed.

Generation 0

This is the youngest generation almost all objects are initially allocated in this generation, unless they are larger than 85,000 bytes in which case they are allocated in LOH.

Most objects are reclaimed by garbage collection in generation 0 however the ones that do survive move on to generation 1.

Generation 1

This generation is a buffer between short lived objects and long-lived objects

Generation 2

This generation contains long lived objects. GC tends to collect objects in this area of memory space quite infrequently.

What Happens During Garbage Collection

A garbage collection has the following steps:
· Marking phase – traverses the graph of all objects and marks them as alive. Each object (‘class’) has a special flag that enables this. Structs in turn do not have this field since they don’t live on the heap

· Relocation of the references to the objects that will be compacted. It should be noted that the GC works around the pinned objects. Pinned objects are usually the ones following by the fixed(…) statement. This pins the object in memory thus allowing to pass the pointer to that object to unmanaged code and at the same time guarantee that the pointer wouldn’t change. This is critical to the correct operation, it also hinders the performance of the garbage collector, hence the use of pinned objects should be minimal.

· Compacting phase that reclaims the space occupied by the dead objects. It moves all objects to the beginning of the memory segment and makes next object pointer, point to the end of the segment.

Originally the LOH was never compacted, which lead to fragmentation and excessive memory usage; however since version of 4.5.1 CLR provides the ability to defragment the LOH by setting ‘GCSettings.LargeObjectHeapCompactionMode

The garbage collector uses the following information to determine whether objects are live:
· Stack roots. Stack variables provided by the just-in-time (JIT) compiler and stack walker.

· Garbage collection handles. Handles that point to managed objects and that can be allocated by user code or by the common language runtime.

· Static data. Static objects in application domains that could be referencing other objects. Each application domain keeps track of its static objects.

Finilizers and Managing Unmanaged Resources

If your object uses any of the unmanaged resources it has to provide the ability to free them. The common pattern is to use ‘IDisposable’ interface to deterministically dispose of unmanaged resources. In case the ‘Dispose’ method isn’t used, the developer should provide a backup, in the form of a Finilizer. The finalizer should only be called if the client code never called the ‘Dispose()’ method. So you logic should handle the case that if the dispose method was called the finaliser never executes. You can achieve that by calling ‘GC.SuppressFinalize(this)’. If you don’t the object will be in freechable queue, then in finalisation queue and even though your object is in Gen0 it will be cleaned up after several garbage collections. ‘GC.SuppressFinalize(this)’ removed the object from the freechable queue eliminating almost all performance drawbacks of having a finilizer. Why almost? Well there is a small catch. When an object has Finilizer it adds itself into freechable queue. If the objects are allocated from different threads and add themselves to freechable queue, that creates contention, theoretically slowing the allocation down due to synchronisation.

To be continued…

There is an issue with Mongo DB (it is an issue if you don’t need that feature). Whenever you pass a date in an entity to a Mongo DB server in a different timezone it will automatically adjust the DateTime value of the object property.

The problem is very easy to solve by decorating the DateTime property with

[BsonDateTimeOptions(Kind = DateTimeKind.Local)]
public DateTime TradeTime { get; set; }

where you do need the time component or

[BsonDateTimeOptions(DateOnly = true)]
public DateTime ReportingDate { get; set; }

when you only care about the date.

An even better solution is to set a global setting of the C# driver:

BsonSerializer.RegisterSerializer(typeof(DateTime), new DateTimeSerializer(DateTimeSerializationOption(DateTimeSerializationOptions.LocalInstance));

I had a one particular view (in the UI) that loaded denormalised data with many repetitive strings. There was nothing much we could do to minimise the volume of the data loaded, however during profiling I realised that most memory was consumer by strings, and most of them were the same.

I remembered a feature of a ‘string’ to intern the value i.e. two or more string having the same value would point to the same memory location without duplication. Applying this technique allowed me to save about 2/3 of the memory consumed. There was one downside though, this memory would never be reclaimed.

So now I’m thinking of writing my own interning using WeakReference