Programming Bytes

If you lack a basic understanding of the size of various data types, I suggest you take a look at: http://programmingbytes.tumblr.com/post/124121068726/what-is-sizeof-int

There are currently 5 main data models:

LP64

ILP64

LLP64

ILP32

LP32

Datatype LP64 ILP64 LLP64 ILP32 LP32 char                8        8          8        8        8 short             16      16        16      16      16 int                 32      64        32      32      16 long              64      64        32      32      32 long long                            64 pointer          64      64        64      32      32

Depending on the data model used by your compiler, the size of primitive data types shall vary.

Your C textbook might say sizeof(int) = 2, and another might say its 4 actually! Quite confusing, and yet both are wrong. If your textbook say its either 2, 4 or something else, its either old or wrong! One way or the other, its time to look for a new book!

The C standard mentions nothing about the size of int or other primitive data types. All it does mention is a range of integers it can hold, and in case of int, -32768 to 32767, which requires 16 bits or 2 bytes minimum.

The keyword here is minimum. Int should be able to hold atleast any numbers within -32768 to 32767, or should be 2 bytes in size minimum. But compilers are free to go beyond that minimum. On 32-bit and most 64-bit systems, you shall see sizeof(int) = 4.

Lets write a simple C program.

#include <stdio.h>

int main() {

    printf(”Sizeof int = %d\n”, sizeof(int));

    printf(”Sizeof int* = %d\n”, sizeof(int*));

}

In 16-bit systems, sizeof int shall probably be 16 bits or 2 bytes. On 32-bit systems, sizeof int shall probably be 32 bits or 4 bytes. But when you run it on 64-bit systems, you might be expecting 64 bits or 8 bytes due to the word size. But chances are, sizeof int in 64 bit systems shall still be 4 bytes.

The interesting thing to note here is sizeof(int*), which is same as the word size of your processor. On 64-bit systems, sizeof(int*) = 8 bytes, and on 32-bit systems, its 4 bytes.

Another thing worth mentioning is about sizeof(long) and sizeof(short). On your system, sizeof(int), sizeof(long), sizeof(short) might have the same value. All C standard mentions is the range of values:

short: -32768 to 32767

int: -32768 to 32767

long: 2147483648 to 2147483647

All the above are signed values. Since short, int, long can be held in a 4 byte memory, chances are sizeof int, short, long shall be 4 bytes (if you are having a 64 bit system).

A couple of things to remember:

A short int must not be larger than an int.

An int must not be larger than a long int.

A short int must be at least 16 bits long.

An int must be at least 16 bits long.

A long int must be at least 32 bits long.

A long long int must be at least 64 bits long.

if you need to understand why compilers choose these sizes, have a look though: http://www.unix.org/version2/whatsnew/lp64_wp.html

But sizeof(char) is fixed and is 1 byte. If you need bigger width char types, have a look at the wide character data type - wchar_t.

I have heard this question over and over - Why doesn’t C support function overloading? Rather than quoting C standard back to you, I thought I shall take a practical approach.

Let’s write a simple C program.

#include <stdio.h>

void func() {

  printf(”Hello World!\n”);

}

int main() {

  func();

  return 0;

}

Compile it, and get the binary. Those who are familiar with Linux, shall know the nm command. Lets apply that on the binary, and we get the below output.

0000000000601040 B __bss_start 0000000000601040 b completed.6335 0000000000601030 D __data_start 0000000000601030 W data_start 00000000004004a0 t deregister_tm_clones 0000000000400510 t __do_global_dtors_aux 0000000000600e08 t __do_global_dtors_aux_fini_array_entry 0000000000601038 D __dso_handle 0000000000600e18 d _DYNAMIC 0000000000601040 D _edata 0000000000601048 B _end 0000000000400604 T _fini 0000000000400530 t frame_dummy 0000000000600e00 t __frame_dummy_init_array_entry 0000000000400768 r __FRAME_END__ 000000000040055d T func 0000000000601000 d _GLOBAL_OFFSET_TABLE_                                  w __gmon_start__ 0000000000400408 T _init 0000000000600e08 t __init_array_end 0000000000600e00 t __init_array_start 0000000000400610 R _IO_stdin_used                                  w _ITM_deregisterTMCloneTable                                  w _ITM_registerTMCloneTable 0000000000600e10 d __JCR_END__ 0000000000600e10 d __JCR_LIST__                                  w _Jv_RegisterClasses 0000000000400600 T __libc_csu_fini 0000000000400590 T __libc_csu_init                                  U __libc_start_main@@GLIBC_2.2.5 000000000040056d T main                                  U puts@@GLIBC_2.2.5 00000000004004d0 t register_tm_clones 0000000000400470 T _start 0000000000601040 D __TMC_END__

Please keep in mind that it can vary with compiler.

If you look through the above output, you shall see the func function.

Now, let’s compile the same program using G++ compiler, and apply the nm command on the new binary.

0000000000601040 B __bss_start 0000000000601040 b completed.6335 0000000000601030 D __data_start 0000000000601030 W data_start 0000000000400560 t deregister_tm_clones 00000000004005d0 t __do_global_dtors_aux 0000000000600dd8 t __do_global_dtors_aux_fini_array_entry 0000000000601038 D __dso_handle 0000000000600de8 d _DYNAMIC 0000000000601040 D _edata 0000000000601048 B _end 00000000004006b4 T _fini 00000000004005f0 t frame_dummy 0000000000600dd0 t __frame_dummy_init_array_entry 0000000000400818 r __FRAME_END__ 0000000000601000 d _GLOBAL_OFFSET_TABLE_                                  w __gmon_start__ 00000000004004d0 T _init 0000000000600dd8 t __init_array_end 0000000000600dd0 t __init_array_start 00000000004006c0 R _IO_stdin_used                                  w _ITM_deregisterTMCloneTable                                  w _ITM_registerTMCloneTable 0000000000600de0 d __JCR_END__ 0000000000600de0 d __JCR_LIST__                                  w _Jv_RegisterClasses 00000000004006b0 T __libc_csu_fini 0000000000400640 T __libc_csu_init                                  U __libc_start_main@@GLIBC_2.2.5 000000000040062d T main                                  U puts@@GLIBC_2.2.5 0000000000400590 t register_tm_clones 0000000000400530 T _start 0000000000601040 D __TMC_END__ 000000000040061d T _Z4funcv

There is no func function! What happened really is that the G++ compiler changed the name of func symbol to _Z4funcv! So when you overload your functions in your C++ code, even though they have the same name in the source code, they have different symbol names in the binary. Its called name mangling.

So if you write a C++ code having a func() function, make it into a library, and try calling it from C, you shall get a “undefined reference to func()”. The reason being that in the C++ library, instead of func, its _Z4funcv. But you can solve this issue by putting the C++ code inside “extern C” block.

#include <stdio.h>

extern “C” {

  void func() {

    printf(”Hello World!\n”);

  }

}

int main() {

  func();

  return 0;

}

Lets compile it using G++ compiler and see the nm output.

0000000000601040 B __bss_start 0000000000601040 b completed.6335 0000000000601030 D __data_start 0000000000601030 W data_start 0000000000400560 t deregister_tm_clones 00000000004005d0 t __do_global_dtors_aux 0000000000600dd8 t __do_global_dtors_aux_fini_array_entry 0000000000601038 D __dso_handle 0000000000600de8 d _DYNAMIC 0000000000601040 D _edata 0000000000601048 B _end 00000000004006b4 T _fini 00000000004005f0 t frame_dummy 0000000000600dd0 t __frame_dummy_init_array_entry 0000000000400818 r __FRAME_END__ 000000000040061d T func 0000000000601000 d _GLOBAL_OFFSET_TABLE_                                  w __gmon_start__ 00000000004004d0 T _init 0000000000600dd8 t __init_array_end 0000000000600dd0 t __init_array_start 00000000004006c0 R _IO_stdin_used                                  w _ITM_deregisterTMCloneTable                                  w _ITM_registerTMCloneTable 0000000000600de0 d __JCR_END__ 0000000000600de0 d __JCR_LIST__                                  w _Jv_RegisterClasses 00000000004006b0 T __libc_csu_fini 0000000000400640 T __libc_csu_init                                  U __libc_start_main@@GLIBC_2.2.5 000000000040062d T main                                  U puts@@GLIBC_2.2.5 0000000000400590 t register_tm_clones 0000000000400530 T _start 0000000000601040 D __TMC_END__

Yes! We now have the func symbol in the binary! We can now make it into a C++ library and shall have no problem calling it from C code.

Any function declared/defined within extern C block shall have C linkage, meaning that you can’t have overloaded functions within extern C block (hope you can figure that out yourselves!)

If you look through some C++ libraries, you shall see code like the below.

#ifdef __cplusplus

extern “C” {

#endif

 // All functions declared here.

#ifdef __cplusplus

}

#endif

__cplusplus macro is defined by every C++ compiler, and hence the “extern C” block shall become visible only when compiled using a C++ compiler.

A lot have already been written about Heroku, but if you browse the web, chances are you won't find much information on Heroku when it comes to PHP.. So I shall walk you through the steps to get your first app running.

Signup for a Heroku account

Download and install Heroku Toolbelt. Git is already bundled along with it.

Open up your command prompt, and navigate to your app folder using the cd command

Login to Heroku, using heroku login. Enter your email address and password, and you shall be authenticated. Once you login, you shall need to create a key.

Once you completed that, type git init. It shall initialize your app folder with an empty git repo.

Type git add .

Type heroku create appname. Change appname to any name of your choice. If you want some random name, use the command heroku create

Type git commit -m "Initial commit"

Type git push heroku master

You have started learning web designing and development. You have designed your first web app. Voila! But contrary to mobile apps, you need to host your web app on some server so that you can show off your impressive web app to others. Shelling out $5 a month on shared hosting for your first app doesn't sound like a good idea. Enter Heroku!

Heroku is a PaaS, and if my memory serves me right, it may be the first PaaS offering too. For your first PHP app, Heroku may sound like a good option. With 512MB of RAM, 2TB bandwidth/month, and plenty more features, you wont have to think beyond Heroku. But most of its features seem to be documented, and you probably shall find less support for PHP from the open source community.

Those familiar with jQuery shall already be familiar with the standard fadeIn() and fadeOut() functions to implement the same. But in case, you are running on pure JavaScript, you may have to implement your own functions for fading and fading out HTML elements.

Given below, is my implementation of the same.

// ID of the element to fadein and fadeout          

content        = document.getElementById("content"),

function setOpacity(id, opacity) {   id.style.opacity = opacity / 100;   id.style.filter = "alpha(opacity=" + opacity + ")"; } function fadeOut(id, opacity) {   setOpacity(id, opacity);   if(opacity == 1) {     id.style.display = "none";   } } function fadeIn(id, opacity) {   setOpacity(id, opacity);   if (opacity == 1) {     id.style.display = "block";   } }

// Perform FadeIn         

for(var i = 100; i >= 1; i--) {   setTimeout((function(x){     return function(){       fadeOut(content, x);     };   })(i), (i - 100) * 5);                                                                                     }

// Perform FadeOut            

There may be a time when you need to hide a specific PHP file from unauthorized users, rather than displaying an Unauthorized Error message. Its quite a simple method, but it can take a skilled opponent to figure it out.

The code is given below:

<?php

// If Authentication Fails if(condition) {   header('HTTP/1.0 404 Not Found');   header('Location: 404.php');   exit(); }

?>

You may be hard pressed to find one who hasn't heard about Pinterest. After all, most of us are certainly addicted to Pinterest in one way or the other. Pinterest currently drives more referral traffic than any websites in the web. To think that Pinterest was the same website which was stumbling in the dark with a 10k user base even after 9 months, is astonishing! They have certainly come a long way. Kudos to the Pinterest team!

Even though women rule the court in Pinterest, more men are joining Pinterest with every single day. The reason may be due to the fact that you dont have to be on a shopping frenzy to start using this social website. And many of us may be wondering, why is it so darn addictive?

We all know that a picture tells us 1000 words. If that's the case, Pinterest tells us a lot more words! And its certainly not images, but the images. We can get to browse through thousands of images through Google Image search. But the images shared on Pinterest seem too professional and visually stunning.

The visual appeal of Pinterest is quite stunning. They have popularized the famed grid layout. Before Pinterest, none of us may be using the grid layout. But these days, its one of the most sought after design style in this industry. Pinterest have gone through various minor and major design changes to make it more appealing to the users. And to me, it seems that they have been successful with that.

Most of us may have stumbled across the Facebook 404 Error page (Page Not Found) at one time or the other. If you have not seen it before, given below is the Facebook 404 Error page.

This is the standard page that shall appear when you try to browse a webpage that does not exist in the Facebook servers (or even pages that you are not authorized to view). The same page shall appear if you try to lookup files in various file formats like htm, html, php, c, c++, py, pdf, doc, docx and so on.

But interestingly, I stumbled across some file formats for which this Error page does not work like png, jpg, gif, css, and js, and you shall see the following page below.

Now this page certainly does not look like an Error page to me. Its not customized to Facebook, and all it has is a link back to the Facebook home page. Maybe, its a php script that is meant to catch any that slips the 404 Error page. Who knows?!

Most newbie web designers start using the DOCTYPE tag, without fully grasping its importance. In reality, the DOCTYPE tag is not an html tag. And as a result, ancient web browsers never required any DOCTYPE tags. They shall parse the web document and shall auto-detect the type based on the tags and attributes within the web document.

These days, the DOCTYPE tag is certainly the first line in most websites. If you have not noticed it before, check the source of any website, and you shall see it. Its recommended that the first line of your html document be the DOCTYPE tag, above the html tag. Its actually an instruction to the web browser about the version of the HTML that the document is written in. It shall help the web browser to render the document perfectly.

Even though HTML5 has been around us for some time now, there are plenty of web designers sticking to the older versions, HTML 4.01. As per HTML4.01, there are three variations of DOCTYPE tags that you can use.

1) HTML 4.01 STRICT

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">

These DTD can be used when your web document contains all HTML attributes, but not any depreciated elements like the font. Also, framesets are not allowed either.

2) HTML 4.01 TRANSITIONAL

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

This DTD is less strict than STRICT, as you can even include depreciated and presentational elements, but framesets are still not allowed.

3) HTML 4.01 FRAMESET

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">

This DTD is same as TRANSITIONAL, with the only difference being that you can include framesets in your web document.

HTML5 DOCTYPE

Since HTML5 is not based on SGML(though HTML 4.01 was based on SGML), it does not require a reference to DTD. But still, its recommended that you have a DOCTYPE tag so that the browser can understand which version of HTML your web document is running.