Nice write up on the OpenStruct object in ruby!

However, I have to do my due diligence here. For most (all?) cases, using OpenStruct is a terrible anti-pattern. Any OpenStruct object will respond to any method you call on it and if it doesn’t exist, returns nil. This causes uncertainty within the system and makes testing a nightmare.

As I recommend to most people, you’re better off using a PORO (plain old ruby object)!

The send button on the conversation should be un-clickable, if a message has already been sent but has not received a response

Wouldn’t this mean that if you never get a response, you can’t use the app anymore?

As a man who had to wear boys’ pants (trousers) for much of his adult life, I feel the same way – for an equivalent waist size, boys’ pockets are usually smaller. I suspect the reason is because boys have shorter arms than men for a given waist size. If the pockets are too deep, then it’s awkward to retrieve small objects from the pockets. I wonder if something similar is true for ladies’ jeans.

One-line summary for the impatient: A BSD proponent defends systemd (at a BSD conference) and suggests that BSD can take ideas from it

Interesting talk.

The whole point of shell scripting is getting shit done and move on to focus on more important stuff.

Once the script takes the life of its own and try to grow up, just spend some time on this teenager and make it speak in a real adult language. Another option that is sometimes preferable would be keeping it young and little, while replacing its limbs with cybernetics made of the real grownup stuff.

The problem turns out to be some obscure FUSE mounts that the author had lying around in a broken state, which subsequently broke the kernel namespace system. Meanwhile, I have been running systemd on every computer I’ve owned in many years and have never had a problem with it.

Does this not seem a bit melodramatic?

Interesting, but I was hoping the conclusion was going to be a bit deeper than what seems obvious to me – that the number of edges directed in must equal the number of edges directed out for each node in the graph. I’m also confused by the term “move”, which I associate with a move in checkers or chess. I’m not a mathematician so perhaps I lack an appreciation for rigor.

6/20 and the only AWS service in the quiz I even knew existed was EC2 (but I got that question wrong).

These icons take cubism to a whole new level.

Interesting post. I never realized that vi was just a wrapper around ed/ex! I am surprised there’s no mention of sed, the next in line after qed and ed in the genealogy of the non-interactive editing tools.

Regarding the editor wars, I recall a mini-war back in the day between elvis, nvi, and vim. Some linux distros used elvis as their default for what gets invoked when a user typed “vi”; others used nvi, and others used vim. I don’t remember which vi clones went with which distributions, but I do remember getting flamed in the #vi channel for not knowing the difference between vi, elvis, and vim. The end result was I decided all those guys are nutty and switched to joe (which was familiar due to my Turbo C background). I am now a hardcore vim user, but still yearn for an editor with a function key template, to satisfy my inner WordPerfect-raised child.

std::enable_if does kinda suck. But isn’t that why constexpr if was added to C++17? It’s both more elegant and takes less mental energy to grok.

I LOVE YOU.

The question wrestled with here is whether the source code was directly copied from CP/M to create QDOS. This isn’t the only relevant question; also relevant is whether QDOS copied the API.

Starting with commands, we have:

CP/M   86-DOS  Meaning
------------------------------------
ERA    DEL    Delete a file
DIR    DIR    List files on disk
REN    REN    Rename a file
SAVE   ?      Save a file to disk
TYPE   TYPE   Print the contents of a file to the console

What about system calls?

#   CP/M                   86-DOS
----------------------------------------------
0   System Reset           Program Terminate
1   Console Input          Console Input
2   Console Output         Console Output
3   Reader Input           Auxiliary Input
4   Punch Output           Auxiliary Output
5   List Output            Printer Output
6   Direct Console I/O     Direct Console I/O
7   Get I/O Byte           ?
8   Set I/O Byte           ?
9   Print String           Output String
10   Read Console Buffer   Input String
11   Get Console Status    Check Console Status
12   Return Version Number ?
13   Reset Disk System     Disk System Reset
14   Select Disk           Select Default Drive
15   Open File             Open File
16   Close File            Close File
17   Search for First      Search for First
18   Search for Next       Search for Next
19   Delete File           Delete File
20   Read Sequential       Sequential Read
21   Write Sequential      Sequential Write
22   Make File             Create File
23   Rename File           Rename File
24   Return Login Vector   ?
25   Return Current Disk   Get Default Drive
26   Set DMA Address       Set Disk I/O Address
27   Get Addr (Alloc)      Allocation Address
28   Write Protect Disk    ?
29   Get Read/Only Vector  ?
30   Set File Attributes   ?
31   Get Addr (Disk Parms) Parameter Address
32   Set/Get User Code     ?
33   Read Random           Random Read
34   Write Random          Random Write
35   Compute File Size     Get File Size
36   Set Random Rector     Get File Address

Of these, the only one that’s really different is the last one (#36). The others are the same, as I understand, to facilitate porting code from CP/M to 86-DOS. Sounds a lot like the Oracle/Google debate/lawsuit to me.

There are more similarities, too, beyond just the API. Both systems have a jump vector to make it easy to port to new hardware:

CP/M              86-DOS
---------------------------------------
4A00  JMP BOOT    0400  JMP INIT
4A03  JMP WBOOT   0403  JMP STATUS
4A06  JMP CONST   0406  JMP CONIN
4A09  JMP CONIN   0409  JMP CONOUT
4A0C  JMP CONOUT  040C  JMP PRINT
4A0F  JMP LIST    040F JMP AUXIN
4A12  JMP PUNCH   0412 JMP AUXOUT
4A15  JMP READER  0415 JMP READ
4A18  JMP HOME    0418  JMP WRITE
4A1B  JMP SELDISK 041B  JMP FLUSH
4A1E  JMP SETTRK  x
4A21  JMP SETSEC  x
4A24  JMP SETDMA  x
4A27  JMP READ    x
4A2A  JMP WRITE   x
4A2D  JMP LISTST  x
4A30  JMP SECTRAN x

So 86-DOS skips some entries like WBOOT, but for the most part, these entries line up.

Any how about the boot loaders? They look superficially different, but I think there are some interesting similarities.

CP/M                                    86-DOS
---------------------------------------------------------------------------------------
cold:
  lxi b,2 ; b=0, c=sector 2             MOV DI,LOAD  
  mvi d,sects                           MOV DX,SECTOR               
  lxi h,ccp                             MOV BL,2                    

lsect:                                  SECT:
  ; load the next sector                  MOV AL,0D0H ; Force interrupt command
                                          OUT DISK    ; To force Type I status
  ;    insert inline code at this         AAM                       
  ;    point to read 128 byte sector      CMP BL,MAXSECT+1 
  ;    from the track given in            JNZ NOSTEP   
  ;    register b, sector given in        MOV AL,58H ; Step in with update
  ;    register c, into the address       CALL DCOM
  ;    given by <hl>                      MOV BL,1
  ;                                     NOSTEP:
  ; branch to location "cold" if a        MOV AL,BL
  ; read error occurs                     OUTB DISK+2  
                                          inb disk ; Get head load status
                                          NOT AL
                                          AND AL,20H   
                                          JZ OUTCOM
                                          MOV AL,4
                                        OUTCOM:
                                          OR AL,READCOM
                                          OUTB DISK
                                          MOV CX,128   
                                          PUSH DI
                                        READ:
  ; ************************              INB DISK+4   
  ; * user supplied read                  TEST AL,DONEBIT
  ; * operation goes here...              JNZ DONE
  ; ************************              INB DISK+3   
                                          STOB
                                          LOOP READ
  dcr d ; sects=sects-1                 DONE:                       
                                          POP DI
  jz boot ; head for the bios             CALL GETSTAT 
    ; more sectors to load                
    ; we aren't using a stack,
    ; so use <sp> as as scratch
    ; register to hold the load        
    ; address segment                     
  lxi sp,128 ; 128 bytes per sector       
  dad sp ; <hl> = <hl> + 128              
  incr c ; sector = sector + 1                                      
  cpi 27 ; last sector of track?         AND AL,9CH
  jc lsect ; no, go read another         JNZ SECT
    ; end of track, increment to         ADD DI,128
    ; next track
  mvi c,1 ; sector = 1                                              
  inr b ; track = track + 1              INC BL
                                         DEC DX
  jmp lsect ; for another group          JNZ SECT           
                                         JMP 0,SEG
                                       DCOM:
                                         OUT DISK
                                         AAM

Sources:

• http://bitsavers.trailing-edge.com/pdf/digitalResearch/cpm/2.0/CPM_2_0_Interface_Guide_1979.pdf
• http://bitsavers.trailing-edge.com/pdf/digitalResearch/cpm/2.0/CPM_2_0_System_Alteration_Guide_1979.pdf
• http://www.patersontech.com/dos/docs/86_dos_prog.pdf

“We need a more complex build system” seems to be a pretty common trap. “We had our reasons” is always offered, but some years later there’s always a monumental undertaking to replace it. There’s a few projects I’m thinking of where building resembles an iterative process of building tools to build to tools to generate python scripts that create make files that build tools… “But that was the only way to create a debug build for windows!”

You think you have a problem nobody else has? You open this door, you’re really going to have problems nobody else has.

Having PRIMARY and CLIPBOARD is a good thing and once you get used to it, it’s like having two clipboards.

Shame he never tells how to actually use them both. Afaict only the primary selection is usable with the default binds.

XTerm.VT100.translations: #override \n\
        Ctrl Shift <Key>C: copy-selection(CLIPBOARD) \n\
        Ctrl Shift <Key>V: insert-selection(CLIPBOARD)

Now if only I could get all the other software to support them both as well.

EDIT: Another tip. If you find the font sizes available in the menu to be ridiculous, they’re pretty easy to change.

XTerm*faceSize1: 8
XTerm*faceSize2: 10
XTerm*faceSize3: 13
XTerm*faceSize4: 16
XTerm*faceSize5: 20
XTerm*faceSize6: 26

faceSize1 corresponds to “Unreadable.”

Now would someone give me key binds to decrease/increase font size? :-)

The argument against succinctness seems odd to me. Yes, regular expressions (the example given) are notoriously succinct, but is

a(b{3,10}|c*)d

really harder to read than

("a" (or (repeat "b" 3 10) (any "c") "d")

or some other notation? The verbose one might be easier to read for someone unfamiliar with regex notation, but once you’ve learned regexes, it becomes a lot easier to see “the whole picture” with a succinct notation (IMHO).

It’s like saying we should write arithmetic like (to use an example that totally isn’t a real programming language ahem):

ADD 1 TO X GIVING Y

instead of

Y = 1 + X

Mathematical notation is notoriously succinct, and it has succeeded because it makes communicating mathematics much easier (yes, I’m intentionally echoing “Notation as a Tool of Thought” here). Standard mathematical notation is the world’s most common DSL and is so common as to be ubiquitous. It is also notoriously succinct.

Many of the arguments in TFA against regex notation seem to be at least partially answered by extended regex notation, which allows whitespace. To whit:

a
(
  b{3,10}
|
  c*
)
d

is just as if not more readable as the s-expr above (again IMHO) and still lets me see the trees and the forest.

I suppose the argument comes down to ease-of-use for beginners versus ease-of-use for experienced users. Experienced users want brevity and conciseness and beginners what code that is self-explanatory.

a.out binaries are smaller than elf binaries, so let’s statically link everything into one big executable ala busybox.

Similarly, a modular kernel with all its modules takes up more total space than a single kernel with everything built in. So don’t even bother implementing modules. Linux 1.2 was the last great Linux before they ruined everything with modules.

64-bit code takes up more space than 32-bit, so let’s build for 32-bit instruction sets. Who has more than 4GB of addressable memory anyway?

Optimized code usually takes up more space, often a lot more when inlining is enabled. Let’s build everything with -Os so we can fit more binaries on our floppies.

Icons are really superfluous anyway, but maybe we’ll want X11R5 or some other GUI on a second floppy. (I’d say X11R6 but all those extensions take up too much space). Make sure to use an 8-bit storage format with a common palette – 24-bit or 32-bit formats are wasteful.

(I lament the bloated nature of the modern OS as much as the next Oregon Trail Generation hacker, but really – is “fits on a 1.7MB floppy really the right metric? Surely we can at least afford to buy 2.88MB drives now?)

Is there any room for innovation in sound-reduction here? I’ve always imagine something like double-glazed glass panels rising up from the backs of desks, maybe all the way to the roof. With a good vacuum between the glass I thought maybe you’d cut down on some noise, especially if the sound travels through multiple of these screens. Certainly the windows in my house cut down the outside noise a bit. And you’d still let light through, which would make them less grim than gray panels.

The yet-another open-plan office blog post is a terrible, horrible, no good, very bad idea.

After years of sitting in an office by myself, I’ve come to prefer an open floor plan. I find ten floor mates preferable to the loneliness of an office, and less distracting than one or two office mates.

I like this comment: “By the way, every few years a new Management Philosophy is announced and the previous Management Philosophy is denounced. Matrix Management seems to have been a product of the Industrial Revolution. It was superseded in the 1970s by Management By Objectives, which was superseded in the 1980s by Theory Z. I don’t know what the latest Management Theory is called. In any event, Matrix Management has been rather thoroughly discredited. I do know that it doesn’t work very well.”