jeberle

I love how egregiously bad CDE looks compared to Windows. Whoever made that call, dios mio.

Also, the images were ruinously far off from what they intended to convey. Dude, just draw a picture by hand & take a picture of it.

Is there any sense in buying (out-of-the money) put options, to make sure you can taste some of that sweet lucre that your overlords are getting?

The good stuff landed in Java 8, so you left the party too early. From Java 8 on it has changed direction completely (less OO + JavaBeans, more functional + ADTs). It feels like a completely different language from the Java 1.4 / 5 days.

https://en.wikipedia.org/wiki/Java_version_history#Java_SE_8...

I could not help but notice the PCB color scheme. Black on white had to be deliberate. Nicely played.

Before that, page-mode terminals used <Return> to move to first field on a subsequent line (like a line-based <Tab>) and sent the page only on <Enter> or <Fn-key>. This made for quick navigation w/ zero ambiguity.

I use it similarly, but I add spots for side x side as well as left, center, right. I only use Hammerspoon for this and a couple tiny things, but it's completely worth it for this alone. Use math to specify window sizes & location. Insanity.

  local mode = hs.screen.primaryScreen():currentMode()
  local mods = {"ctrl", "alt", "cmd"}  -- mash those keys
  
  -- regular app windows
  do
    local w   = 1094  -- no clip on GitHub, HN
    local h   = 1122  -- tallish
    local x_1 =    0                               -- left edge
    local x_2 = math.max(0, (mode.w - w - w) / 2)  -- left middle
    local x_3 =             (mode.w - w) / 2       -- middle
    local x_4 = math.min(mode.w - w, x_2 + w + 1)  -- right middle
    local x_5 =          mode.w - w                -- right edge
    local y   =   23  -- top of screen below menu bar
  
    hs.hotkey.bind(mods, "2", function() move_win(  0, y, mode.w, mode.h) end)  -- max
  
    hs.hotkey.bind(mods, "3", function() move_win(x_1, y, w, h) end)
    hs.hotkey.bind(mods, "4", function() move_win(x_2, y, w, h) end)
    hs.hotkey.bind(mods, "5", function() move_win(x_3, y, w, h) end)
    hs.hotkey.bind(mods, "6", function() move_win(x_4, y, w, h) end)
    hs.hotkey.bind(mods, "7", function() move_win(x_5, y, w, h) end)
  end
  
  function move_win(x, y, w, h)
    hs.window.focusedWindow():setFrame(hs.geometry.rect(x, y, w, h))
  end

The "no taste" quote makes no sense given that Susan Kare did the many of the significant icons in Windows 95. She did the same for the Mac.

Does Rice's theorem cover this?

[ all non-trivial semantic properties of programs are undecidable ]

https://en.wikipedia.org/wiki/Rice's_theorem

Found here:

From Sumatra to Panama, from Babylon to Valhalla

https://www.youtube.com/watch?v=bE1bRbZzQ_k&t=48m27s

That's the basis for my critique of CSS. There were plenty of other layout systems extant at the time CSS was cooked up. How CSS could have delivered such an incomplete and broken scheme is beyond me. To this day, it sucks harder than GridBagLayout from AWT of the 90s (and that one sucks a quite bit).

Thanks for this. It's pointless to argue, but I wonder if shifting from 32 to 64 bits, instead 128, would have seen faster uptake.

Aside, isn't embedding MAC addrs in ones IP address a bad idea?

Cat constructed from block: Unified Canadian Aboriginal Syllabics, U+1400 to U+167F

  U+14DA  ᓚ CANADIAN SYLLABICS LA
  U+160F  ᘏ CANADIAN SYLLABICS CARRIER YO
  U+15E2  ᗢ CANADIAN SYLLABICS CARRIER TTU

I would look to the UCSD p-System as a precedent to the JVM. Both are byte-code interpreted VMs. Gosling used the p-system earlier in his career, prior to joining Sun.

https://en.wikipedia.org/wiki/James_Gosling#Career_and_contr...

The Objective-C runtime is very small: just enough to do late-bound fn calls to a tree of class defs. All on top of C.

mod_php was distributed w/ Apache httpd, so it was "already installed". mod_perl needed to be installed manually, so it posed immediate friction, if not a complete freeze-out, depending on the situ. I believe that was why PHP became popular.

Yeah, FFM adds many quality-of-life features - scoped lifetimes being a standout.

If you just want an arena interface, ByteBuffer has been there since Java 1.4 (2002). It also does off-heap w/ ByteBuffer.allocateDirect().

https://docs.oracle.com/en/java/javase/25/docs/api/java.base...

Not sure what you mean by "primitive support". Java 22 added FFM (Foreign Function & Memory). It works w/ both on-heap & off-heap memory. It has an Arena interface.

https://openjdk.org/jeps/454

https://docs.oracle.com/en/java/javase/25/docs/api/java.base...

That was my first reaction. It's not like Java is terribly slow, so rewriting it in a slightly faster language seems like an empty exercise.

I've often wondered if PostScript or PDF contained the roots of a very good config language. Perhaps it simply is (PDF docs at least) but nobody regards it as such.

My guess is the RPN nature would be a no-go for many people. Nevertheless: comments, dicts, arrays, good string syntax, numerics, binary data, etc. Maybe that makes it too complicated.

Ah, you're right: $10K/yr + $0.15/unit. I was thinking more of a BOM part that already did HDMI, making it a no-brainer. Just speculating.

I would find the product more compelling in a puck form factor (sans kbd). I can't imagine missing the extra key labels. That would make it significantly smaller, more robust, & less expensive.

I'd also prefer DisplayPort to HDMI, but that might have been chosen for cost, or for the home gaming / nostalgia play.

My favorite in this vein: The Parable of the Two Programmers, by Neil W. Rickert. Sums things up nicely.

https://c00kiemon5ter.github.io/code/philosophy/2011/10/30/T...

OK, I'm lost here. Why is there a 1:1 correspondence between the two?

You forgot `- 2^11` for the surrogate pairs. Gee, why isn't Unicode 2^21 code points? To understand the Unicode code point space you must understand UTF-16. The code space is defined by how UTF-16 works. That was my initial point.

UTF-16 arguably is Unicode 2.0+. It's how the code point address space is defined. Code points are either 1 or 2 16-bit code units. Easy. Compare w/ UTF-8 where a code point may be 1, 2, 3, or 4 8-bit code units.

UTF-16 is annoying, but it's far from the biggest design failure in Unicode.

Likewise, I would kill for gaps between Esc/F1, F4/F5, and F8/F9. ThinkPads do this although it is very subtle.

The gaps let you use the the function keys by feel rather than looking at them. They tend to be mapped in debuggers so hitting the wrong key is a big deal.

I actually don't mind the smaller arrow keys as again, they make it easier to drive by feel rather than by looking.

The RST parser is available in only one language, Python. I don't want my content tied to a single language stack, regardless of how good it might be. Markdown parsers exist in any language I care to use.

Makes sense given that IBM already had the POWER arch & AIX, which was based on BSD rather than SysV for Solaris.

I think what's important is that the name matches on /ian/.

That is very cool. I had a similar boot disk w/ DOS 3.x and TurboPascal. It made any PC I could walk up to a complete developer box.

Just to be clear, when you say "without the need for the GUI", more accurately that's "without a GUI" (w/o Presentation Manager). So you're using OS/2 in an 80x25 console screen, what would appear to be a very good DOS box.

Despite it being everyone's favorite shame language, COBOL's DATA DIVISION makes it uniquely well-suited for long-term stability. Common practice is to avoid binary fields. This means what you see in your program is what you see on the wire or in a file.