HN user

swatson741

3,146 karma
Posts236
Comments71
View on HN
franz.com 6mo ago

Lisp Coding Standards v1.0

swatson741
2pts0
www2.eecs.berkeley.edu 6mo ago

Computer Science Illustrated (2009) [pdf]

swatson741
1pts0
arxiv.org 6mo ago

The Sparsely-Gated Mixture-of-Experts Layer (2017) [pdf]

swatson741
1pts0
ycalumni.store 6mo ago

Y Combinator Store

swatson741
2pts1
dl.acm.org 6mo ago

CYC: A large-scale investment in knowledge infrastructure (1995) [pdf]

swatson741
4pts0
x.ai 7mo ago

Grok's Phone Number

swatson741
2pts1
waymo.com 7mo ago

Waymo Safety Impact

swatson741
2pts0
www.microsoft.com 7mo ago

Wearing the hair shirt: a retrospective on Haskell (2003)

swatson741
3pts0
sourceforge.net 7mo ago

OpenCyc 4.0

swatson741
3pts1
inst.eecs.berkeley.edu 7mo ago

Introduction to Artificial Intelligence

swatson741
3pts0
github.com 7mo ago

GitHub Copilot CLI

swatson741
1pts0
www.arduino.cc 7mo ago

Arduino UNO Q

swatson741
4pts0
www.youtube.com 7mo ago

60 Years of Artificial Intelligence at Stanford (2023) [video]

swatson741
1pts0
thegithubshop.com 7mo ago

GitHub Shop

swatson741
2pts4
swatson555.github.io 7mo ago

Essentials of Compilation: An Incremental Approach (2020)

swatson741
11pts0
pagespeed.web.dev 7mo ago

Google PageSpeed Insights

swatson741
2pts0
epsil.github.io 7mo ago

General Parser Combinators in Racket (2012)

swatson741
3pts0
www.dourish.com 7mo ago

Jargon.txt (1988)

swatson741
2pts0
aima.cs.berkeley.edu 7mo ago

Artificial Intelligence: A Modern Approach

swatson741
4pts0
www.youtube.com 7mo ago

Three Directions in Design: Gerald Jay Sussman (2024) [video]

swatson741
3pts1
arxiv.org 7mo ago

Bayesian Neural Networks (2018) [pdf]

swatson741
1pts0
cs61a.org 8mo ago

CS 61A: Structure and Interpretation of Computer Programs

swatson741
2pts0
www.paulgraham.com 8mo ago

The Hundred-Year Language (2003)

swatson741
3pts0
www.youtube.com 8mo ago

Practical Common Lisp (2006) [video]

swatson741
2pts0
nanopass.org 8mo ago

Nanopass Framework

swatson741
3pts0
projecteuler.net 8mo ago

Project Euler

swatson741
566pts134
github.com 8mo ago

ChezScheme v10.3.0

swatson741
3pts0
softwarepreservation.computerhistory.org 8mo ago

An Algebraic Language for the Manipulation of Symbolic Expressions (1958) [pdf]

swatson741
101pts11
hackaday.com 8mo ago

Heroes of the Hardware Revolution: Bob Widler (2014)

swatson741
1pts0
karpathy.medium.com 8mo ago

Backpropagation is a leaky abstraction (2016)

swatson741
353pts160

I saw this happen to my Canvas account today. At first I thought it was a prank from the school or Instructure. The message was sent to students which makes no sense. Second, the message that was sent basically implies that ShinyHunter is actively getting patched out, and no one is ever going to give into their demands. They're basically saying that they're done and desperate. It's a strange message for ShinyHunter to send, but I think they were trying to pull off a psyop / FUD.

Looking into the payload they sent me this is how they hijacked the screen. Everything in the payload is unchanged except for one line of code:

<link rel="stylesheet" href="https://instructure-uploads.s3.amazonaws.com/account_9363000..." media="all"/>

This links to the following styling sheet:

@import url('https://fonts.googleapis.com/css2?family=Orbitron:wght@500;7...');

html, body { height: 100% !important; overflow: hidden !important; margin: 0 !important; padding: 0 !important; }

body > * { display: none !important; }

body { display: flex !important; align-items: center !important; justify-content: center !important; background: #07080c !important; }

body::before { content: "" !important; position: fixed !important; inset: 0 !important; z-index: 999998 !important; background: radial-gradient(ellipse at 50% 20%, rgba(255,59,59,.06), transparent 55%), radial-gradient(ellipse at 50% 85%, rgba(125,70,152,.04), transparent 45%), repeating-linear-gradient(0deg, rgba(255,255,255,.035), rgba(255,255,255,.035) 1px, transparent 1px, transparent 3px), #07080c !important; pointer-events: none !important; }

body::after { content: "\A\A" "S H I N Y H U N T E R S" "\A" "rooting your systems since '19 ;)" "\A\A\A" "ShinyHunters has breached Instructure (again)." "\A" "Instead of contacting us to resolve it they" "\A" "ignored us and did some \201Csecurity patches\201D." "\A\A" "\26A0 W A R N I N G" "\A\A" "If any of the schools in the affected list are" "\A" "interested in preventing the release of their" "\A" "data, please consult with a cyber advisory firm" "\A" "and contact us privately at TOX to negotiate a" "\A" "settlement. You have till the end of the day by" "\A" "12 May 2026 before everything is leaked." "\A\A" "Instructure still has until EOD 12 May 2026" "\A" "to contact us." "\A\A" " \25BC DOWNLOAD AFFECTED_SCHOOLS.TXT \25BC" "\A" "91.215.85.103/pay_or_leak/" "\A" "instructure_affected_schools_list.txt" "\A\A" "visit us: shnyhntww34phqoa6dcgnvps2yu7dlwzmy5" "\A" "lkvejwjdo6z7bmgshzayd.onion" !important;

    position: fixed !important;
    z-index: 999999 !important;
    top: 50% !important;
    left: 50% !important;
    transform: translate(-50%, -50%) !important;
    white-space: pre !important;
    text-align: center !important;
    font-family: 'Fira Code', 'Share Tech Mono', monospace !important;
    font-size: clamp(10px, 1.4vw, 14px) !important;
    line-height: 1.55 !important;
    color: #c8dce8 !important;
    background:
        linear-gradient(180deg, rgba(255,255,255,.05) 0%, rgba(255,255,255,.01) 3.2%, transparent 3.2%) !important;
    background-color: #0d0f16 !important;
    border: 2px solid #ff3b3b !important;
    border-radius: 14px !important;
    padding: 16px 32px !important;
    overflow: hidden !important;
    box-shadow:
        0 0 35px rgba(255,59,59,.2),
        0 40px 90px rgba(0,0,0,.65),
        inset 0 0 0 1px rgba(255,255,255,.06),
        inset 0 0 50px rgba(255,59,59,.03) !important;
    animation: pulseWarn 2.5s infinite ease-in-out !important;
    max-width: 94vw !important;
    text-shadow: 0 0 6px rgba(200,220,232,.15) !important;
}

@keyframes pulseWarn { 0% { box-shadow: 0 0 20px rgba(255,59,59,.15), 0 40px 90px rgba(0,0,0,.65), inset 0 0 0 1px rgba(255,255,255,.06); } 50% { box-shadow: 0 0 55px rgba(255,59,59,.4), 0 40px 90px rgba(0,0,0,.65), inset 0 0 0 1px rgba(255,255,255,.06); } 100% { box-shadow: 0 0 20px rgba(255,59,59,.15), 0 40px 90px rgba(0,0,0,.65), inset 0 0 0 1px rgba(255,255,255,.06); } }

The hack is crude, and it seems unlikely that they have any access to Instructure's developer tools.

Eat Real Food 7 months ago

I dunno about this. The problem mainly affects low-income families and residents of food deserts, and now the government is trying to put everyone on a keto diet. It just seems like they're not fixing the problems where they happen.

I never really considered this too deeply, because I've never studied "Agentic AI" before (except for natural language processing). Stallman is making a really good point. ChatGPT doesn't solve the intelligence problem. If ChatGPT was actually able to do that it would be able to make ChatGPT 2.0 on request.

I think the term transpiler is ok. It’s not pedagogical or anything but most engineering jargon is like that, and this defiantly isn’t the worst one I’ve seen.

So he wants a good parallel language? What's the issue? I haven't had problems with concurrency, multiplexing, and promises. They've solved all the parallelism tasks I've needed to do.

Norvig actually did comment on this publicly once on the Lex Friedman podcast. Basically what he said was that lisp ended up not working well for larger software projects with 5 or more people on them, and the reason why they never used lisp in any of their books again was because students didn't like lisp. Norvig doesn't seem to get why students didn't like lisp, and neither do I but somehow this is the real reason why it was abandoned.

https://youtu.be/_VPxEcT_Adc?t=2690

We know in hindsight that lisp became most useful for representing computation, but what ever happened to AI? McCarthy says it's characteristic of LISP. SICP also mentions AI as being fundamental to lisp at the beginning of the book. Norvig & Russel used Common Lisp for the first edition of their book. But, then what happened? Why did it just disappear for no reason?

You're right `virtmach` only works on things that are output from `compile` and maintaining the invariant that virtmach lisp uses those pointers isn't difficult to do in with how the evaluator is presented.

It gives virtmach lisp and scheme different ontology, but I can't think of any practical reason why that would matter other than it makes things a little bit more complicated. But, then again if I'm thinking practically scheme should be using hashed identifiers, and then there's no reason for them to have different ontology and conceptually we're right back where we started with virtmach lisp and scheme using identifiers as objects.

A C compiler can output fairly readable code if you turn off optimizations, and it's definitely not going to take thousands of lines to do this in modern assembly. It may be only just barely a thousand lines to do this in aarch64, and the LLM can probably do it.

From what I've seen the LLM do it can definitely enhance these programs if you know what to ask, and it can explain how any piece this code works. It may even be able to add garbage collection to the evaluator since the root registers are explicit, and the evaluator only acts on static memory.

You'll still probably need the `strcmp` because the pointers won't be the same unless you check for them and make them the same.

You may be thinking about how `eq?` (reference equality) works in scheme. That's usually done by hashing the identifier string. Which is the more general solution to this equality problem.

The Japanese paper culture is pretty wild. They use them to make fusuma (sliding doors), decorative strips, gift wrapping, etc. And like they say in the report they've done this since forever. There was once a time in history when the rest of the world was stuck using solid shutters instead of superior paper windows.

BTW the reporter looks like Cotten Hill if he was real, and actually fought in all those wars. I'm quite surprised they had him hosting the video. I'm curious what decisions led to this.

Very true but the other side of this is first class continuations are no worse than compiling try-catch semantics, and hygienic macros are still just macros so the complexity is kept simple (sort of. maybe simple isn't always so simple).

The other thing that makes languages like scheme difficult to compile are those closures. In fact, the book, the implementation of functional programming languages, Jones (1987) didn't do it at all! No closure conversion at all. They just compiled to a letrec in the g-machine.

They certainly came up with a lot of good one-liners for this book.

I wonder why Dennis Ritchie was so infuriated though. He criticizes them for wanting simple functionality, but it's not because language is a powerful tool for solving problems it's because it limits the potential of the platform to it's functionality (which has been simplified and in of itself limited).

So this is confusing to me. Using language to solve problems is the advantage that Unix offers. But, neither the authors nor Dennis care about this? Or they do care in limited ways, but ultimately it's about something else?

The paper has this to say:

Choice is a fundamental feature of all functional logic languages. In VC, choice is expressed in the syntax of the term (“laid out in space”) rather than, as is more typical, handled by non-deterministic rewrites and backtracking (“laid out in time”). This makes VC completely deterministic, unlike most functional logic languages which are non-deterministic by design (Section 6.1).

So, the language is deterministic which is a result of being confluent. And going to section 6.1 as suggested says this:

In contrast, our rules never pick one side or the other of a choice. And yet, (3 +(20 | 30)) can still make progress by floating out the choice (rule choose in Fig. 3), thus (3 +20) | (3 +30). In effect, choices are laid out in space (in the syntax of the term), rather than being explored by non-deterministic selection. Rule choose is not a new idea.

So the syntax is "ambiguous" and given context with "choose" to make it unambiguous.

To answer your question more plainly it's the ambiguity that's important. Non-determinism usually follows as a natural consequent.

However, it may be a hinderance or it may be desired. Usually we're only interested in one single useful result. But, if I do a search in a data structure for all occurrences of X, and there are 5 of them then I may want a result of all 5 occurrences of X.

Maybe I'm not understanding the insight here, but it sort of seams like having confluence defeats the purpose of logical semantics.

My specific concern is that by having logical semantics in a language you can represent non-deterministic ambiguous computations, but for this you need divergent paths which, if I understand correctly, the authors have removed from their language. So what's the point of doing this?

I agree with all of this. Moreover depending on what Torvalds chooses to do Apple may have ended up with a more expensive XNU in the end which would have been a disaster. Although I think Apple can deal with Torvalds just fine who really knows how that would have played out.

Whenever I see the Darwin kernel brought into the discussion I can't help but wonder how different things could have been if Apple had just forked Linux and ran their OS services on top of that.

Especially when I think about how committed they are to Darwin it really paints a poor image in my mind. The loss that open source suffers from that, and the time and money Apple has to dedicate to this with a disproportionate return.

I did mean sum types, variants, etc. It's not really clear what I meant by representing the data but I'm referring to type inference. SML can't solve the problem, and Lisp doesn't have it.

Defiantly worth studying SML imo. Pattern matching is a cool feature. Although it's not as comprehensive as most of the pattern matchers in Lisp. You can't match on bitfields, comparisons other than equality by value, etc.

Datatypes are just ok. Classes would be better. It's sort of strange to represent lists (and everything else) as enumerations. It's not really essential or fundamental but I guess that's what Lisp is for.