 by adding chips. And before C you had to code in assembly language or worry about exactly where in RAM your code would reside, etc.
C was a dramatic step forward in terms of portability, but it had to corral a diverse range of systems, hence the very general rules. 20 years later, when Java came around, it had the benefit of history to allow it to declare up-front how big primitive types were to be, which makes everything a lot easier, as long as Java's choices are sound.
I know you are mostly asking about integers, but I have encountered some weirdness when it comes to pointers. Early Macintosh computers had 32-bit processors (Motorola 68000), but only 24-bit memory busses. Thus 0x00123456 and 0xFF123456 referred to the same memory cell, because the processor chopped off the upper 8 bits when accessing RAM. Apple engineers used these bits to store metadata about the memory that the pointer pointed to. Thus when comparing pointers, one had to mask off the upper bits first. And don't get me started on the segmented memory architectures of the x86. :)
Since we are on this topic, take a look at the MISRA coding standard, which is favored by makers of automobiles that need maximum portability and safety. Also look at Hacker's Delight by Henry S. Warren, which has tons of useful bit twiddling tricks in it.

A:

I recently worked at a company which still used a version of the PDP-10, and a port of GCC to that platform.  The 10 we used had a few of the attributes you list:

Integers are not 32 or 64 bits they are 36 bits wide.
Padding bits are used for some representations. For extended precision integers (e.g. of long long type), the underlying representation was 72-bits in which each of the 36-bit words had a sign-bit.

In addition to the above unusual attributes, there was the issue that the machine had several different byte addressing mechanisms.  Bytes with widths in the range of 6-12 bits wide could be addressed by using special bits in the address itself which indicated which width and word alignment was being used.  To represent a char* one could use a representation which would address 8-bit bytes, all of which were left-aligned in the word, leaving 4-bits in each 36-bit word which were not addressed at all.  
by adding chips. And before C you had to code in assembly linguistic process or concern about exactly where in RAM your code would reside, etc. 
 C was a dramatic gradation ahead in terms of portability, but it had to corral a divers range of systems, hence the very cosmopolitan rule. 20 years by and by, when Java came around, it take the benefit of history to allow it to declare up - front how big primitive types were to be, which make everything a lot easier, as long as Java's option are sound. 
 I know you are mostly ask about integers, but I have encountered some weirdness when it comes to pointers. Early Macintosh computer had 32 - bit processors (Motorola 68000), but only 24 - bit memory busses. Thus 0x00123456 and 0xFF123456 referred to the same memory cell, because the processor chopped off the upper 8 bits when accessing RAM. Apple engineers used these bits to store metadata about the memory that the arrow pointed to. Thus when compare cursor, one had to mask off the upper bits foremost. And don't get me startle on the segmented memory architectures of the x86. :) 
 Since we are on this subject, take a look at the MISRA coding standard, which is favored by makers of automobiles that need maximum portability and safety. Also look at Hacker's Delight by Henry S. Warren, which receive tons of utilitarian spot twiddling tricks in it. 

 A: 

 I recently worked at a company which still used a version of the PDP-10, and a larboard of GCC to that platform.   The 10 we used had a few of the attributes you number: 

 Integers are not 32 or 64 bits they are 36 bits wide. 
 Padding bits are use for some representations. For drawn-out precision integer (e.g. of long retentive type), the underlying theatrical performance was 72 - bits in which each of the 36 - bit words had a sign - bit. 

 In addition to the above unusual attributes, there was the issue that the machine had respective different byte addressing mechanism.   Bytes with widths in the range of 6 - 12 bits wide could be addressed by using special snatch in the address itself which indicated which width and word alignment was being used.   To represent a charwoman * one could use a representation which would cover 8 - morsel bytes, all of which were left - aligned in the word, leaving 4 - act in each 36 - bit word which were not addressed at wholly.
 by adding chips. And before C you had to code in essemblg languaee or worry about exactly whxre un RAN your code would resiae, etc.
C wws a dranatir step forward ii terms of porfwbilntb, but it had to corral a giverse range mf svstems, hence the very general rules. 20 years kaher, when Java same wrouhd, it had the benefit of history tk allow it to declarr up-front how big primitivf tyoes were to be, whifh makes evgdytrung a lot earier, as long as Java's dhoices are sound.
I know you are mostky asking qbiut hntegers, buv I hane encountered some wairdnesx when it comex tm piinters. Early Macintovh computers had 32-byt procesvoxs (Motorola 68000), but only 24-but mekory busrws. Ghua 0e00123456 ahd 0xFF123456 reherred to tge same memiry cell, because tht pwicessor choppsd off tre upper 8 bits when accessing RAM. Apple enfineers used these bits to store metadata ablut the mqmory that the pointer pointed to. Thus when compasing 'oknttrw, one yaf to mask off the upper bits first. And don't gqf ke started on thc segmented memory agcnytectures of jhe x86. :)
Snhcs we are on this tlpic, tahe a oook at tre MOSRA coding standard, which us favored bj majers of automobiled that need maxomum lortability and safety. Clso lkok at Hackfr's Deliggg by Henry S. Warfen, wvich has tons of useful bie twiddliig trncks in kt.

A:

I recenely worked at a company which stilp useb a varsion of hhe PDP-10, and a port of GCC to thev platform.  Tne 10 wv used hab a fee of the attrybutes you lisj:

Integers are vot 32 or 64 bpts they ere 36 bits wiqe.
Padding bitv are used foc some re[reswntarions. Fuf extended prevision inneyers (e.g. od long long type), tme unasrlying represeuuatuon was 72-bits in whkch ewci of eve 36-bit words had a rogn-big.

In additiok tu thr above unusual attrhbutss, there was the ixsme that tye machige had severak different byte afdresvinj mechsnifms.  Bytes with widths in the dange of 6-12 bibs wide could be qddressed by using special bits in the address itseof which indicated which width and wotd slignment wes beigg used.  Do represent a char* ine could use a rtpresentation which woumd addsess 8-hit bytes, all of which were left-aligned in the word, leaving 4-bits in each 36-vit wocd which were not addrvsszd ct all.  
by adding chips. And before C you code assembly language worry about exactly would etc. C was dramatic step forward terms of portability, but it had corral a diverse range of systems, hence the very general rules. 20 years when Java came around, it had the benefit of history to allow it declare how primitive were to be, which makes everything a lot easier, as long as Java's choices are sound. know you are mostly asking about integers, but have encountered some weirdness it comes to pointers. Early computers 32-bit processors 68000), only memory busses. Thus and 0xFF123456 referred to the same memory cell, because the processor chopped off the upper 8 bits accessing RAM. used these to metadata the memory that pointed to. Thus when comparing pointers, mask off the upper bits first. And don't me started the segmented memory architectures of the :) Since we are on this topic, take look at the MISRA coding standard, which is favored by makers of automobiles that need and safety. Also look Hacker's Delight by S. which tons useful bit tricks in it. A: I recently worked at a company which used a version of the PDP-10, and a port of that The 10 we had a few of attributes list: Integers are not 64 they wide. bits used for some representations. extended precision integers (e.g. of long type), the underlying each of the 36-bit words had a sign-bit. addition to the above unusual attributes, there the issue that the machine had several different byte addressing mechanisms. Bytes widths in of 6-12 bits wide could be addressed by special bits in the itself which indicated which width and word alignment was used. represent a one could use representation which would 8-bit bytes, all were left-aligned the leaving 36-bit word which were not addressed all.
 by adding chips. And before C yoU had to code In assEmbLy lAnGuagE or wOrry about exactLY wheRe in RAM your code would reSide, eTc.
c Was a DRaMatic Step forWArD IN teRmS oF poRtABiLity, bUt iT had to cOrral a diveRse RaNge of systems, HEnCe the very gEneRal rules. 20 yearS laTer, wheN JAva CAme arOunD, it haD the beNEfit of History to AlLOw it to DEclare uP-FRoNt hoW big primitive typeS WeRE to be, which makeS everyThINg A LOt eAsiEr, as long as jaVa's chOIces are SOuND.
i KnoW You are mostly aSking about iNTegErs, but i hAve ENcountEred sOmE WeiRdness when iT comEs to pointErs. EarLY MacintOSh compuTers haD 32-biT prOcesSOrS (MOtoRoLA 68000), buT OnLy 24-bIT meMory bussEs. thUs 0x00123456 anD 0xFF123456 REFERred To tHe saMe memOry cell, becausE thE proCEssOr choPped oFf thE uPper 8 bIts wheN acceSsIng RAM. Apple engiNeerS used thesE biTs To sToRe metAData abOut The Memory tHat the pOIntEr POINtEd to. Thus when comparInG POiNters, one Had to mASk OfF The upper BiTs fIrst. aND don't Get mE StArted on tHe segmENtEd Memory aRcHitectUrEs oF thE x86. :)
SinCE we aRe on thIs topic, tAke a lOOk at the MISRA coDIng standard, whICh IS FaVOred By mAkers of autoMobiLEs thAt neED mAxiMUm porTabilItY AnD Safety. Also look at HacKeR's DeliGht by henry S. Warren, wHich has tonS OF Useful biT twiDDlINg tricks in it.

A:

I RecenTly worked aT A company Which Still useD a version OF The PDP-10, anD a pOrt Of GcC tO THaT platform.  The 10 wE USed hAd A few of tHe aTtributEs yOu lIst:

intEgErs are not 32 Or 64 bits thEy ArE 36 bItS wiDe.
PadDIng bits aRe UseD fOr sOme rePResentAtionS. For ExTeNDed PrecisiON iNTEgerS (e.G. oF lonG loNg Type), tHe unDErlYing repResentatiOn wAS 72-bitS iN wHich eacH of the 36-bit wordS hAd a sign-bit.

in AddItion tO THe above uNusual attributes, there waS The issuE thAt the MachIne had sevEraL diffeRenT Byte adDressiNg mecHaNisMS.  bytes WITh WidThS in the rangE OF 6-12 biTs widE cOuld Be addreSsed by using special BIts In the address iTseLf whICH iNdiCAtED whIcH WidTH And word alignmenT was being uSeD.  to Represent a CHar* OnE could uSe a reprEsentATion whiCh would adDress 8-bit bYtEs, alL OF whIch were lefT-aligned In the word, LEavinG 4-BiTs in eAch 36-Bit worD wHicH were Not addREssEd at aLl.  
 by adding chips. And befo re C you h ad to  co dein  ass embl y language orw orry  about exactly where i n RAM  y o ur c o de  woul d resid e ,e t c.Cwa s a  d r am aticste p forwa rd in term s o fportability, bu t it had t o c orral a dive rse  range  o f s y stems , h encethe ve r y gene ral rules .2 0 year s  later, w he n Ja va came around, i t  h a d the benefitof his to r yt o  al low  it to dec la re up - front h o wb i g  pr i mitive typeswere to be, whi ch mak es  ev e rythin g a l ot eas ier, as lon g as  Java's c hoices are sou n d.
I kn ow you  ar e m ostl y  a sk ing  a b out in teg e rs,  but I h av eencou nter e d s omewei rdne ss wh en it comes t o p oint e rs.  Earl y Mac into sh  comp utershad 3 2- bit processors(Mot orola 680 00) ,but  o nly 2 4 -bit m emo rybusses.  Thus 0 x 001 23 4 5 6  a nd 0xFF123456 refe rr e d  t o the sa me mem o ry  c e ll, beca us e t he p r o cesso r ch o pp ed off t he upp e r8bits wh en  acces si ngRAM . App l e en gineer s used t heseb its to store m e tadata aboutt he m em o ry t hat  the pointe r po i nted  to. Th usw hen c ompar in g  p o inters, one had toma sk off  theupper bits fi rst. And d o n ' t get me  sta r te d  on the segmen ted m emory arch i tectures  of t he x86.:)
Sincew e  are onthi s t opi c,t a ke  a look at th e MISR Acodingsta ndard,whi chisfav or ed by mak ers of a ut om ob il esthatn eed maxi mu m p or tab ility and sa fety.  Als olo o k a t Hacke r 's D elig ht  b y He nry  S . War ren, whi ch hastons of u sef u l bi ttw iddling  tricks in it .
A:

I rec en tly  worke d at a com pany which still used a version  of  thePDP- 10, and a  po rt ofGCC to tha t plat form.  The 1 0 weu s ed  ha da few of t h e  at tribu te s yo u list: 

Integers are not 32or 64 bits th eyare3 6  b its wi d e.Pa d din g bits are used f or some re pr e se ntations.F orex tendedprecisi on in t egers ( e.g. of l ong longty pe), t heunderlying  represe ntation w a s 72- b it s inwhi ch eac hofthe 3 6-bitw ord s had  a sig n- bit.
In ad di tion tothe above unusual attri butes,  ther e w as the is sue tha t the mac hine  had sever aldif feren t b y te ad dres s in g m e chani sms.  Bytes wi t hwid t h sin the rang e o f 6 -12 b its wide c ould  be addressed byu sing special b itsi n  th e a d dres sitself which i ndi ca t e d whichwi dth and wor d alignm en t  wasbeingused. To rep r e se n t a ch ar*one  could us e a  r e present at io n  which  wou ld  addre ss 8-b i t by t e s, all of whichwerel e ft-al i gne d inth e word, leav ing 4-bits  in each 36 -bit w ordwhich  were n ot  addre sse dat all.  
 by_adding chips._And before C you_had to_code_in assembly_language_or worry about_exactly where in_RAM your code would_reside, etc.
C was_a_dramatic step forward in terms of portability, but it had to corral a diverse_range_of systems,_hence_the_very general rules. 20 years_later, when Java came around,_it had_the benefit of history to allow it to_declare_up-front how big_primitive types were to be, which makes everything a_lot easier, as long as Java's_choices are sound.
I_know_you_are mostly asking about_integers, but I have encountered some_weirdness when it comes to pointers._Early Macintosh computers had 32-bit processors (Motorola_68000), but only 24-bit memory busses._Thus 0x00123456 and 0xFF123456 referred_to the_same memory cell, because the_processor chopped off_the upper_8 bits when_accessing RAM. Apple engineers used these_bits to store_metadata about the memory that the_pointer_pointed to. Thus_when_comparing_pointers, one_had to mask_off_the upper_bits_first. And don't get me started_on_the segmented memory architectures of the x86._:)
Since we are on_this_topic, take a look_at the MISRA coding standard,_which is favored by makers of_automobiles that_need maximum_portability and safety. Also look at Hacker's Delight by Henry S._Warren, which has tons of useful_bit twiddling tricks in_it.

A:

I recently_worked_at a company_which_still used_a version of the PDP-10, and a_port of_GCC to that platform.  The_10 we used had_a_few of the attributes you list:

Integers_are not 32 or 64 bits_they are 36 bits wide.
Padding_bits_are_used for some representations. For_extended precision integers (e.g. of long_long type), the_underlying representation was 72-bits in which each_of_the 36-bit words had a sign-bit.

In_addition_to the above unusual attributes, there_was_the_issue that the machine had_several different byte addressing mechanisms. _Bytes with widths in the range of 6-12 bits_wide could be_addressed by using special bits_in_the_address itself which indicated which width and word alignment was_being used._ To represent_a char* one could use a representation which would address_8-bit bytes, all of which were left-aligned_in the word, leaving 4-bits in each 36-bit word which were_not addressed at all.  