Harvey Mudd Miniature Machine | Hacker News Reader

Harvey Mudd Miniature Machine

cs.hmc.edu

76 pointsnill024 comments

This is only tangentially related but the best course that actually made real analysis click for me was from Harvey Mudd, seems like a solid university: https://www.youtube.com/playlist?list=PL04BA7A9EB907EDAF

Francis Su is one of the GOATs

Went there, can definitely recommend

That was the class where I really learned how to prove things in math. Very challenging, and rewarding class.

FYI it’s a liberal arts college.

Albeit, a uniquely STEM focused liberal arts college.

It’s legit and their grads are wicked smart.

Hear hear!

Great school. All- undergrad STEM education. Professors teach the classes, not TAs! And you have full access to the facilities of the 4 adjacent colleges (Pomona, CMC, Scripps, Pitzer), each prestigious in their own right.

Would be an interesting project to implement in hardware, now I'm semi-retired it's the kind of thing I might do for a laugh - maybe once I finish writing my next book though..

Is there a collection of sample programs for HMMM?

Nice.

Here's one from (the younger) me:

  =======================
  Description
  =======================
  
  24-bit words (no bytes, so no endianness)
  
  <op> 5 <dir/ind> 1 <r1/cond> 3 <r2> 3 <val> 12
  r2 = 0 means zero value
  
  dir/ind:
  
  0 dir
  1 ind
  
  cond:
  
  001 eq
  010 lt 
  1000 gt
  
  8 regs
  
  r0 = PC
  
  op:
  
  00x xx0 - type independent
  01x xx0 - bitwise
  10x xx0 - integer
  11x xx0 - floating-point
  
  ST 00 ; store (ignores ind/dir)
  LD 02 ; load/move
  BR 04 ; branch (rel/abs)
  
  SL 20 ; shift left
  SR 22 ; shift right
  SA 24 ; shift right arithmetical
  OR 26 ; or
  AN 30 ; and
  OX 32 ; or exclusive (xor)
  NO 34 ; not
  
  AD 40 ; add
  SB 42 ; subtract
  MU 44 ; multiply
  DV 46 ; divide
  CP 50 ; compare
  
  FA 60 ; add
  FS 62 ; subtract
  FM 64 ; multiply
  FD 66 ; divide
  FC 70 ; compare
  
  example:
  
  LD r1, [4096] ; |03121000|
  AD r1, 1      ; |40100001|
  LD r2, r1     ; |02210000|
  SB r2, 33     ; |42200033|
  BR le, exit   ; |04300001|
  ST r1, [4096] ; |01201000|
  exit: .
  
  floating-point format - normalized:
  
  <sign> 1 <exp> 7 <mantissa> 16 + 1 implicit
  
  literals:
  
  decimal: -8,388,608 ... 8,388,607 (can use commas)
  binary (in octal): |42200033|
  floating-point: 1.23e-45
  character sequence 'abc' (3 characters per word)
  
  r0 can be used as a temporary
  
  =======================
  Implementation
  =======================
  
  #include <stdio.h>
  #include <ctype.h>
  
  #define n 1024
  #define trace(op) fprintf(stderr, "%04o %s\n", r0, #op)
  
  enum {
         ST = 000, /* store (ignores ind/dir) */
         LD = 002, /* load/move */
         BR = 004, /* branch (ignores ind/dir) */
  
         SL = 020, /* shift left */
         SR = 022, /* shift right */
         SA = 024, /* shift right arithmetical */
         OR = 026, /* or */
         AN = 030, /* and */
         OX = 032, /* or exclusive (xor) */
         NO = 034, /* not */
  
         AD = 040, /* add */
         SB = 042, /* subtract */
         MU = 044, /* multiply */
         DV = 046, /* divide */
         CP = 050, /* compare */
  
         FA = 060, /* add */
         FS = 062, /* subtract */
         FM = 064, /* multiply */
         FD = 066, /* divide */
         FC = 070 /* compare */
  };
  
  int main() {
         static int b[n];
         /* load image */
         int c, *p, s, z;
         static int r[8];
         for (s = 21, p = b; p < b + n && (c = getchar()) > 0;)
                 if (isdigit(c) && c <= '7') {
                         *p |= (~0x30 & c) << s;
                         if (s)
                                 s -=3;
                         else
                                 s = 21, ++p;
                 }
         /* run image */
         c = 7;
         while (r[0] >= 0 && r[0] < n) {
                 int i, o, d, x, y, v, r0;
                 i = b[r0 = r[0]++]; /* inc PC */
                 o = (i >> 19 & 31) << 1;
                 d = !(i >> 18 & 1);
                 x = i >> 15 & 7;
                 y = i >> 12 & 7;
                 v = ((i << 20) >> 20) + (y ? r[y] : 0); /* assuming 32-bit ints */
                 switch(o) {
                         case ST: b[v] = r[x]; trace(ST); break;
                         case LD: r[x] = d ? v : b[v]; trace(LD); break;
                         case BR: if (x & c) r[0] += v; trace(BR); break;
                         case SL: r[x] <<= v; c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(SL); break;
                         case SR: r[x] >> v; c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(SR); break;
                         case SA: r[x] >> (unsigned) v; c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(SA); break;
                         case OR: r[x] |= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(OR); break;
                         case AN: r[x] &= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(AN); break;
                         case OX: r[x] ^= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(OX); break;
                         case NO: r[x] = ~r[x]; c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(NO); break;
                         case AD: r[x] += (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(AD); break; 
                         case SB: r[x] -= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(SB); break;
                         case MU: r[x] *= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(MU); break;
                         case DV: r[x + 1] = r[x] % (d ? v : b[v]); r[x] /= (d ? v : b[v]); c = r[x] == 0 ? 1 : r[x] < 0 ? 2 : 4; trace(DV); break;
                         case CP: c = r[x] == (d ? v : b[v]) ? 1 : r[x] < (d ? v : b[v]) ? 2 : 4; trace(CP); break;
                         case FA: trace(FA); break; /* TODO */
                         case FS: trace(FS); break; /* TODO */
                         case FM: trace(FM); break; /* TODO */
                         case FD: trace(FD); break; /* TODO */
                         case FC: trace(FC); break; /* TODO */
                 }
         }
         /* print image */
         for (z = 0, p = b; p < b + n; ++p) 
                 if (*p) {
                         int m;
                         if (z) {
                                 puts("00000000");
                                 if (z > 3)
                                         puts("........");
                                 else if (z > 1)
                                         puts("00000000");
                                 if (z > 2)                      
                                         puts("00000000");
                                 z = 0;
                         }
                         for (s = 21, m = 7 << s; m; m >>= 3, s -= 3)
                                 putchar(0x30 | (*p & m) >> s);
                         putchar('\n');
                 }
                 else
                         ++z;
         return 0;
  }
  
  =======================
  Example: Bubble Sort
  =======================
  
  0000 LD r1, 10              ; n = 8        02100010
  
  repeat:
  0001 SB r1, 1               ; n = n - 1    42100001
  0002 LD r2, 0               ; i = 0        02200000
  0003 LD r3, 0               ; f = false    02300000
  
  compare:
  0004 LD r4, [r2 + data]     ;              03420021
  0005 CP r4, [r2 + data + 1] ;              51420022
  0006 BR le, next            ;              04300004
  
  0007 LD r5, [r2 + data + 1] ; swap         03520022
  0010 ST r5, [r2 + data]     ;              00520021
  0011 ST r4, [r2 + data + 1] ;              00420022
  0012 LD r3, 1               ; f = true     02300001
  
  next:
  0013 AD r2, 1               ; i = i + 1    40200001
  0014 CP r2, r1              ; i < n ?      50210000
  0015 BR lt, compare         ;              04207766
  
  0016 CP r3, 0               ; f = false ?  50300000
  0017 BR eq, 2000            ; exit         04102000
  0020 BR   , repeat          ;              04707760
  
  data:
  0021 9                      ;              00000011
  0022 8                      ;              00000010
  0023 5                      ;              00000005
  0024 6                      ;              00000006
  0025 3                      ;              00000003
  0026 7                      ;              00000007
  0027 2                      ;              00000002
  0030 1                      ;              00000001

I got all excited until I realized Harvey Mudd isn't Henry Mudd. This project would have had a lot more cred, in my book, if it were the latter.

I feel like I'm missing something, Henry Mudd Harvey Mudd's son?

I'm guessing he was probably trying to refer to Harry Mudd, the Star Trek character?

Harcourt Fenton Mudd.

https://www.youtube.com/watch?v=2FGgHEKko3E

I'd be more excited if it was by Harry Mudd.

I was hoping for Harry Mudd's android-making machine from Star Trek OG. https://en.wikipedia.org/wiki/I%2C_Mudd

Harvey Mudd is a college in California, mostly specializing in STEM majors.

How does it compare to Stony Brook?

Very different. HMC has fewer than 1000 students, all undergraduates, and is a private college, whereas Stony Brook is a public school with ~25k students including ~8k postgrads.

Mudd is to MIT what Swarthmore is to Chicago.

Dammit, I messed it all up. I meant Harry Mudd from Star Trek, as most correctly guessed.

Harcourt!!!

Haha, fine! I messed it up 2x.

Excited at first ... until he sold you the hMMM machine, took your credits and flew away, only for you to discover that this machine only programs in little endian brainf*ck!

Reply on news.ycombinator.com